dnp3.h

Go to the documentation of this file.

// This library is provided under the terms of a non-commercial license.
// 
// Please refer to the source repository for details:
// 
// https://github.com/stepfunc/dnp3/blob/master/LICENSE.txt
// 
// Please contact Step Function I/O if you are interested in commercial license:
// 
// info@stepfunc.io
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define DNP3_VERSION_MAJOR 1
#define DNP3_VERSION_MINOR 1
#define DNP3_VERSION_PATCH 0
#define DNP3_VERSION_STRING "1.1.0"
 
#include <stdbool.h>
#include <stdint.h>
 
 
typedef enum dnp3_param_error_t
{
    DNP3_PARAM_ERROR_OK = 0,
    DNP3_PARAM_ERROR_INVALID_TIMEOUT = 1,
    DNP3_PARAM_ERROR_NULL_PARAMETER = 2,
    DNP3_PARAM_ERROR_NO_SUPPORT = 3,
    DNP3_PARAM_ERROR_ASSOCIATION_DOES_NOT_EXIST = 4,
    DNP3_PARAM_ERROR_ASSOCIATION_DUPLICATE_ADDRESS = 5,
    DNP3_PARAM_ERROR_INVALID_SOCKET_ADDRESS = 6,
    DNP3_PARAM_ERROR_INVALID_DNP3_ADDRESS = 7,
    DNP3_PARAM_ERROR_INVALID_BUFFER_SIZE = 8,
    DNP3_PARAM_ERROR_ADDRESS_FILTER_CONFLICT = 9,
    DNP3_PARAM_ERROR_SERVER_ALREADY_STARTED = 10,
    DNP3_PARAM_ERROR_SERVER_BIND_ERROR = 11,
    DNP3_PARAM_ERROR_MASTER_ALREADY_SHUTDOWN = 12,
    DNP3_PARAM_ERROR_RUNTIME_CREATION_FAILURE = 13,
    DNP3_PARAM_ERROR_RUNTIME_DESTROYED = 14,
    DNP3_PARAM_ERROR_RUNTIME_CANNOT_BLOCK_WITHIN_ASYNC = 15,
    DNP3_PARAM_ERROR_LOGGING_ALREADY_CONFIGURED = 16,
    DNP3_PARAM_ERROR_POINT_DOES_NOT_EXIST = 17,
    DNP3_PARAM_ERROR_INVALID_PEER_CERTIFICATE = 18,
    DNP3_PARAM_ERROR_INVALID_LOCAL_CERTIFICATE = 19,
    DNP3_PARAM_ERROR_INVALID_PRIVATE_KEY = 20,
    DNP3_PARAM_ERROR_INVALID_DNS_NAME = 21,
    DNP3_PARAM_ERROR_OTHER_TLS_ERROR = 22,
} dnp3_param_error_t;
 
static const char* dnp3_param_error_to_string(dnp3_param_error_t value)
{
    switch (value)
    {
        case DNP3_PARAM_ERROR_OK: return "ok";
        case DNP3_PARAM_ERROR_INVALID_TIMEOUT: return "invalid_timeout";
        case DNP3_PARAM_ERROR_NULL_PARAMETER: return "null_parameter";
        case DNP3_PARAM_ERROR_NO_SUPPORT: return "no_support";
        case DNP3_PARAM_ERROR_ASSOCIATION_DOES_NOT_EXIST: return "association_does_not_exist";
        case DNP3_PARAM_ERROR_ASSOCIATION_DUPLICATE_ADDRESS: return "association_duplicate_address";
        case DNP3_PARAM_ERROR_INVALID_SOCKET_ADDRESS: return "invalid_socket_address";
        case DNP3_PARAM_ERROR_INVALID_DNP3_ADDRESS: return "invalid_dnp3_address";
        case DNP3_PARAM_ERROR_INVALID_BUFFER_SIZE: return "invalid_buffer_size";
        case DNP3_PARAM_ERROR_ADDRESS_FILTER_CONFLICT: return "address_filter_conflict";
        case DNP3_PARAM_ERROR_SERVER_ALREADY_STARTED: return "server_already_started";
        case DNP3_PARAM_ERROR_SERVER_BIND_ERROR: return "server_bind_error";
        case DNP3_PARAM_ERROR_MASTER_ALREADY_SHUTDOWN: return "master_already_shutdown";
        case DNP3_PARAM_ERROR_RUNTIME_CREATION_FAILURE: return "runtime_creation_failure";
        case DNP3_PARAM_ERROR_RUNTIME_DESTROYED: return "runtime_destroyed";
        case DNP3_PARAM_ERROR_RUNTIME_CANNOT_BLOCK_WITHIN_ASYNC: return "runtime_cannot_block_within_async";
        case DNP3_PARAM_ERROR_LOGGING_ALREADY_CONFIGURED: return "logging_already_configured";
        case DNP3_PARAM_ERROR_POINT_DOES_NOT_EXIST: return "point_does_not_exist";
        case DNP3_PARAM_ERROR_INVALID_PEER_CERTIFICATE: return "invalid_peer_certificate";
        case DNP3_PARAM_ERROR_INVALID_LOCAL_CERTIFICATE: return "invalid_local_certificate";
        case DNP3_PARAM_ERROR_INVALID_PRIVATE_KEY: return "invalid_private_key";
        case DNP3_PARAM_ERROR_INVALID_DNS_NAME: return "invalid_dns_name";
        case DNP3_PARAM_ERROR_OTHER_TLS_ERROR: return "other_tls_error";
        default: return "unknown param_error value";
    }
}
 
 
#define DNP3_FLAG_ONLINE 0x01
#define DNP3_FLAG_RESTART 0x02
#define DNP3_FLAG_COMM_LOST 0x04
#define DNP3_FLAG_REMOTE_FORCED 0x08
#define DNP3_FLAG_LOCAL_FORCED 0x10
#define DNP3_FLAG_CHATTER_FILTER 0x20
#define DNP3_FLAG_OVER_RANGE 0x20
#define DNP3_FLAG_DISCONTINUITY 0x40
#define DNP3_FLAG_REFERENCE_ERR 0x40
 
typedef enum dnp3_log_level_t
{
    DNP3_LOG_LEVEL_ERROR = 0,
    DNP3_LOG_LEVEL_WARN = 1,
    DNP3_LOG_LEVEL_INFO = 2,
    DNP3_LOG_LEVEL_DEBUG = 3,
    DNP3_LOG_LEVEL_TRACE = 4,
} dnp3_log_level_t;
 
static const char* dnp3_log_level_to_string(dnp3_log_level_t value)
{
    switch (value)
    {
        case DNP3_LOG_LEVEL_ERROR: return "error";
        case DNP3_LOG_LEVEL_WARN: return "warn";
        case DNP3_LOG_LEVEL_INFO: return "info";
        case DNP3_LOG_LEVEL_DEBUG: return "debug";
        case DNP3_LOG_LEVEL_TRACE: return "trace";
        default: return "unknown log_level value";
    }
}
 
typedef struct dnp3_logging_config_t dnp3_logging_config_t;
 
typedef enum dnp3_log_output_format_t
{
    DNP3_LOG_OUTPUT_FORMAT_TEXT = 0,
    DNP3_LOG_OUTPUT_FORMAT_JSON = 1,
} dnp3_log_output_format_t;
 
static const char* dnp3_log_output_format_to_string(dnp3_log_output_format_t value)
{
    switch (value)
    {
        case DNP3_LOG_OUTPUT_FORMAT_TEXT: return "text";
        case DNP3_LOG_OUTPUT_FORMAT_JSON: return "json";
        default: return "unknown log_output_format value";
    }
}
 
typedef enum dnp3_time_format_t
{
    DNP3_TIME_FORMAT_NONE = 0,
    DNP3_TIME_FORMAT_RFC_3339 = 1,
    DNP3_TIME_FORMAT_SYSTEM = 2,
} dnp3_time_format_t;
 
static const char* dnp3_time_format_to_string(dnp3_time_format_t value)
{
    switch (value)
    {
        case DNP3_TIME_FORMAT_NONE: return "none";
        case DNP3_TIME_FORMAT_RFC_3339: return "rfc_3339";
        case DNP3_TIME_FORMAT_SYSTEM: return "system";
        default: return "unknown time_format value";
    }
}
 
typedef struct dnp3_logging_config_t
{
    dnp3_log_level_t level;
    dnp3_log_output_format_t output_format;
    dnp3_time_format_t time_format;
    bool print_level;
    bool print_module_info;
} dnp3_logging_config_t;
 
static dnp3_logging_config_t dnp3_logging_config_init()
{
    dnp3_logging_config_t _return_value = {
        DNP3_LOG_LEVEL_INFO,
        DNP3_LOG_OUTPUT_FORMAT_TEXT,
        DNP3_TIME_FORMAT_SYSTEM,
        true,
        false
    };
    return _return_value;
}
 
 
typedef struct dnp3_logger_t
{
    
    void (*on_message)(dnp3_log_level_t, const char*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_logger_t;
 
static dnp3_logger_t dnp3_logger_init(
    void (*on_message)(dnp3_log_level_t, const char*, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_logger_t _return_value = {
        on_message,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
dnp3_param_error_t dnp3_configure_logging(dnp3_logging_config_t config, dnp3_logger_t logger);
 
 
typedef enum dnp3_app_decode_level_t
{
    DNP3_APP_DECODE_LEVEL_NOTHING = 0,
    DNP3_APP_DECODE_LEVEL_HEADER = 1,
    DNP3_APP_DECODE_LEVEL_OBJECT_HEADERS = 2,
    DNP3_APP_DECODE_LEVEL_OBJECT_VALUES = 3,
} dnp3_app_decode_level_t;
 
static const char* dnp3_app_decode_level_to_string(dnp3_app_decode_level_t value)
{
    switch (value)
    {
        case DNP3_APP_DECODE_LEVEL_NOTHING: return "nothing";
        case DNP3_APP_DECODE_LEVEL_HEADER: return "header";
        case DNP3_APP_DECODE_LEVEL_OBJECT_HEADERS: return "object_headers";
        case DNP3_APP_DECODE_LEVEL_OBJECT_VALUES: return "object_values";
        default: return "unknown app_decode_level value";
    }
}
 
typedef enum dnp3_transport_decode_level_t
{
    DNP3_TRANSPORT_DECODE_LEVEL_NOTHING = 0,
    DNP3_TRANSPORT_DECODE_LEVEL_HEADER = 1,
    DNP3_TRANSPORT_DECODE_LEVEL_PAYLOAD = 2,
} dnp3_transport_decode_level_t;
 
static const char* dnp3_transport_decode_level_to_string(dnp3_transport_decode_level_t value)
{
    switch (value)
    {
        case DNP3_TRANSPORT_DECODE_LEVEL_NOTHING: return "nothing";
        case DNP3_TRANSPORT_DECODE_LEVEL_HEADER: return "header";
        case DNP3_TRANSPORT_DECODE_LEVEL_PAYLOAD: return "payload";
        default: return "unknown transport_decode_level value";
    }
}
 
typedef enum dnp3_link_decode_level_t
{
    DNP3_LINK_DECODE_LEVEL_NOTHING = 0,
    DNP3_LINK_DECODE_LEVEL_HEADER = 1,
    DNP3_LINK_DECODE_LEVEL_PAYLOAD = 2,
} dnp3_link_decode_level_t;
 
static const char* dnp3_link_decode_level_to_string(dnp3_link_decode_level_t value)
{
    switch (value)
    {
        case DNP3_LINK_DECODE_LEVEL_NOTHING: return "nothing";
        case DNP3_LINK_DECODE_LEVEL_HEADER: return "header";
        case DNP3_LINK_DECODE_LEVEL_PAYLOAD: return "payload";
        default: return "unknown link_decode_level value";
    }
}
 
typedef enum dnp3_phys_decode_level_t
{
    DNP3_PHYS_DECODE_LEVEL_NOTHING = 0,
    DNP3_PHYS_DECODE_LEVEL_LENGTH = 1,
    DNP3_PHYS_DECODE_LEVEL_DATA = 2,
} dnp3_phys_decode_level_t;
 
static const char* dnp3_phys_decode_level_to_string(dnp3_phys_decode_level_t value)
{
    switch (value)
    {
        case DNP3_PHYS_DECODE_LEVEL_NOTHING: return "nothing";
        case DNP3_PHYS_DECODE_LEVEL_LENGTH: return "length";
        case DNP3_PHYS_DECODE_LEVEL_DATA: return "data";
        default: return "unknown phys_decode_level value";
    }
}
 
typedef struct dnp3_decode_level_t dnp3_decode_level_t;
 
typedef struct dnp3_decode_level_t
{
    dnp3_app_decode_level_t application;
    dnp3_transport_decode_level_t transport;
    dnp3_link_decode_level_t link;
    dnp3_phys_decode_level_t physical;
} dnp3_decode_level_t;
 
static dnp3_decode_level_t dnp3_decode_level_init()
{
    dnp3_decode_level_t _return_value = {
        DNP3_APP_DECODE_LEVEL_NOTHING,
        DNP3_TRANSPORT_DECODE_LEVEL_NOTHING,
        DNP3_LINK_DECODE_LEVEL_NOTHING,
        DNP3_PHYS_DECODE_LEVEL_NOTHING
    };
    return _return_value;
}
 
static dnp3_decode_level_t dnp3_decode_level_nothing()
{
    dnp3_decode_level_t _return_value = {
        DNP3_APP_DECODE_LEVEL_NOTHING,
        DNP3_TRANSPORT_DECODE_LEVEL_NOTHING,
        DNP3_LINK_DECODE_LEVEL_NOTHING,
        DNP3_PHYS_DECODE_LEVEL_NOTHING
    };
    return _return_value;
}
 
 
typedef struct dnp3_runtime_t dnp3_runtime_t;
 
typedef struct dnp3_runtime_config_t dnp3_runtime_config_t;
 
typedef struct dnp3_runtime_config_t
{
    uint16_t num_core_threads;
} dnp3_runtime_config_t;
 
static dnp3_runtime_config_t dnp3_runtime_config_init()
{
    dnp3_runtime_config_t _return_value = {
        0
    };
    return _return_value;
}
 
 
dnp3_param_error_t dnp3_runtime_create(dnp3_runtime_config_t config, dnp3_runtime_t** out);
 
void dnp3_runtime_destroy(dnp3_runtime_t* instance);
 
 
typedef struct dnp3_control_field_t dnp3_control_field_t;
 
typedef struct dnp3_control_field_t
{
    bool fir;
    bool fin;
    bool con;
    bool uns;
    uint8_t seq;
} dnp3_control_field_t;
 
 
typedef enum dnp3_trip_close_code_t
{
    DNP3_TRIP_CLOSE_CODE_NUL = 0,
    DNP3_TRIP_CLOSE_CODE_CLOSE = 1,
    DNP3_TRIP_CLOSE_CODE_TRIP = 2,
    DNP3_TRIP_CLOSE_CODE_RESERVED = 3,
} dnp3_trip_close_code_t;
 
static const char* dnp3_trip_close_code_to_string(dnp3_trip_close_code_t value)
{
    switch (value)
    {
        case DNP3_TRIP_CLOSE_CODE_NUL: return "nul";
        case DNP3_TRIP_CLOSE_CODE_CLOSE: return "close";
        case DNP3_TRIP_CLOSE_CODE_TRIP: return "trip";
        case DNP3_TRIP_CLOSE_CODE_RESERVED: return "reserved";
        default: return "unknown trip_close_code value";
    }
}
 
typedef enum dnp3_op_type_t
{
    DNP3_OP_TYPE_NUL = 0,
    DNP3_OP_TYPE_PULSE_ON = 1,
    DNP3_OP_TYPE_PULSE_OFF = 2,
    DNP3_OP_TYPE_LATCH_ON = 3,
    DNP3_OP_TYPE_LATCH_OFF = 4,
} dnp3_op_type_t;
 
static const char* dnp3_op_type_to_string(dnp3_op_type_t value)
{
    switch (value)
    {
        case DNP3_OP_TYPE_NUL: return "nul";
        case DNP3_OP_TYPE_PULSE_ON: return "pulse_on";
        case DNP3_OP_TYPE_PULSE_OFF: return "pulse_off";
        case DNP3_OP_TYPE_LATCH_ON: return "latch_on";
        case DNP3_OP_TYPE_LATCH_OFF: return "latch_off";
        default: return "unknown op_type value";
    }
}
 
typedef struct dnp3_control_code_t dnp3_control_code_t;
 
typedef struct dnp3_control_code_t
{
    dnp3_trip_close_code_t tcc;
    bool clear;
    bool queue;
    dnp3_op_type_t op_type;
} dnp3_control_code_t;
 
static dnp3_control_code_t dnp3_control_code_init(dnp3_trip_close_code_t tcc, bool clear, dnp3_op_type_t op_type)
{
    dnp3_control_code_t _return_value = {
        tcc,
        clear,
        false,
        op_type
    };
    return _return_value;
}
 
static dnp3_control_code_t dnp3_control_code_from_op_type(dnp3_op_type_t op_type)
{
    dnp3_control_code_t _return_value = {
        DNP3_TRIP_CLOSE_CODE_NUL,
        false,
        false,
        op_type
    };
    return _return_value;
}
 
static dnp3_control_code_t dnp3_control_code_from_tcc_and_op_type(dnp3_trip_close_code_t tcc, dnp3_op_type_t op_type)
{
    dnp3_control_code_t _return_value = {
        tcc,
        false,
        false,
        op_type
    };
    return _return_value;
}
 
 
typedef struct dnp3_group12_var1_t dnp3_group12_var1_t;
 
typedef struct dnp3_group12_var1_t
{
    dnp3_control_code_t code;
    uint8_t count;
    uint32_t on_time;
    uint32_t off_time;
} dnp3_group12_var1_t;
 
static dnp3_group12_var1_t dnp3_group12_var1_init(dnp3_control_code_t code, uint8_t count, uint32_t on_time, uint32_t off_time)
{
    dnp3_group12_var1_t _return_value = {
        code,
        count,
        on_time,
        off_time
    };
    return _return_value;
}
 
static dnp3_group12_var1_t dnp3_group12_var1_from_code(dnp3_control_code_t code)
{
    dnp3_group12_var1_t _return_value = {
        code,
        1,
        1000,
        1000
    };
    return _return_value;
}
 
 
typedef struct dnp3_flags_t dnp3_flags_t;
 
typedef struct dnp3_flags_t
{
    uint8_t value;
} dnp3_flags_t;
 
static dnp3_flags_t dnp3_flags_init(uint8_t value)
{
    dnp3_flags_t _return_value = {
        value
    };
    return _return_value;
}
 
 
typedef enum dnp3_time_quality_t
{
    DNP3_TIME_QUALITY_SYNCHRONIZED_TIME = 0,
    DNP3_TIME_QUALITY_UNSYNCHRONIZED_TIME = 1,
    DNP3_TIME_QUALITY_INVALID_TIME = 2,
} dnp3_time_quality_t;
 
static const char* dnp3_time_quality_to_string(dnp3_time_quality_t value)
{
    switch (value)
    {
        case DNP3_TIME_QUALITY_SYNCHRONIZED_TIME: return "synchronized_time";
        case DNP3_TIME_QUALITY_UNSYNCHRONIZED_TIME: return "unsynchronized_time";
        case DNP3_TIME_QUALITY_INVALID_TIME: return "invalid_time";
        default: return "unknown time_quality value";
    }
}
 
typedef struct dnp3_timestamp_t dnp3_timestamp_t;
 
typedef struct dnp3_timestamp_t
{
    uint64_t value;
    dnp3_time_quality_t quality;
} dnp3_timestamp_t;
 
static dnp3_timestamp_t dnp3_timestamp_invalid_timestamp()
{
    dnp3_timestamp_t _return_value = {
        0,
        DNP3_TIME_QUALITY_INVALID_TIME
    };
    return _return_value;
}
 
static dnp3_timestamp_t dnp3_timestamp_synchronized_timestamp(uint64_t value)
{
    dnp3_timestamp_t _return_value = {
        value,
        DNP3_TIME_QUALITY_SYNCHRONIZED_TIME
    };
    return _return_value;
}
 
static dnp3_timestamp_t dnp3_timestamp_unsynchronized_timestamp(uint64_t value)
{
    dnp3_timestamp_t _return_value = {
        value,
        DNP3_TIME_QUALITY_UNSYNCHRONIZED_TIME
    };
    return _return_value;
}
 
 
typedef enum dnp3_double_bit_t
{
    DNP3_DOUBLE_BIT_INTERMEDIATE = 0,
    DNP3_DOUBLE_BIT_DETERMINED_OFF = 1,
    DNP3_DOUBLE_BIT_DETERMINED_ON = 2,
    DNP3_DOUBLE_BIT_INDETERMINATE = 3,
} dnp3_double_bit_t;
 
static const char* dnp3_double_bit_to_string(dnp3_double_bit_t value)
{
    switch (value)
    {
        case DNP3_DOUBLE_BIT_INTERMEDIATE: return "intermediate";
        case DNP3_DOUBLE_BIT_DETERMINED_OFF: return "determined_off";
        case DNP3_DOUBLE_BIT_DETERMINED_ON: return "determined_on";
        case DNP3_DOUBLE_BIT_INDETERMINATE: return "indeterminate";
        default: return "unknown double_bit value";
    }
}
 
typedef struct dnp3_binary_input_t dnp3_binary_input_t;
 
typedef struct dnp3_binary_input_t
{
    uint16_t index;
    bool value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_binary_input_t;
 
static dnp3_binary_input_t dnp3_binary_input_init(uint16_t index, bool value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    dnp3_binary_input_t _return_value = {
        index,
        value,
        flags,
        time
    };
    return _return_value;
}
 
 
typedef struct dnp3_binary_input_iterator_t dnp3_binary_input_iterator_t;
 
dnp3_binary_input_t* dnp3_binary_input_iterator_next(dnp3_binary_input_iterator_t* iter);
 
 
typedef struct dnp3_double_bit_binary_input_t dnp3_double_bit_binary_input_t;
 
typedef struct dnp3_double_bit_binary_input_t
{
    uint16_t index;
    dnp3_double_bit_t value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_double_bit_binary_input_t;
 
static dnp3_double_bit_binary_input_t dnp3_double_bit_binary_input_init(uint16_t index, dnp3_double_bit_t value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    dnp3_double_bit_binary_input_t _return_value = {
        index,
        value,
        flags,
        time
    };
    return _return_value;
}
 
 
typedef struct dnp3_double_bit_binary_input_iterator_t dnp3_double_bit_binary_input_iterator_t;
 
dnp3_double_bit_binary_input_t* dnp3_double_bit_binary_input_iterator_next(dnp3_double_bit_binary_input_iterator_t* iter);
 
 
typedef struct dnp3_binary_output_status_t dnp3_binary_output_status_t;
 
typedef struct dnp3_binary_output_status_t
{
    uint16_t index;
    bool value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_binary_output_status_t;
 
static dnp3_binary_output_status_t dnp3_binary_output_status_init(uint16_t index, bool value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    dnp3_binary_output_status_t _return_value = {
        index,
        value,
        flags,
        time
    };
    return _return_value;
}
 
 
typedef struct dnp3_binary_output_status_iterator_t dnp3_binary_output_status_iterator_t;
 
dnp3_binary_output_status_t* dnp3_binary_output_status_iterator_next(dnp3_binary_output_status_iterator_t* iter);
 
 
typedef struct dnp3_counter_t dnp3_counter_t;
 
typedef struct dnp3_counter_t
{
    uint16_t index;
    uint32_t value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_counter_t;
 
static dnp3_counter_t dnp3_counter_init(uint16_t index, uint32_t value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    dnp3_counter_t _return_value = {
        index,
        value,
        flags,
        time
    };
    return _return_value;
}
 
 
typedef struct dnp3_counter_iterator_t dnp3_counter_iterator_t;
 
dnp3_counter_t* dnp3_counter_iterator_next(dnp3_counter_iterator_t* iter);
 
 
typedef struct dnp3_frozen_counter_t dnp3_frozen_counter_t;
 
typedef struct dnp3_frozen_counter_t
{
    uint16_t index;
    uint32_t value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_frozen_counter_t;
 
static dnp3_frozen_counter_t dnp3_frozen_counter_init(uint16_t index, uint32_t value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    dnp3_frozen_counter_t _return_value = {
        index,
        value,
        flags,
        time
    };
    return _return_value;
}
 
 
typedef struct dnp3_frozen_counter_iterator_t dnp3_frozen_counter_iterator_t;
 
dnp3_frozen_counter_t* dnp3_frozen_counter_iterator_next(dnp3_frozen_counter_iterator_t* iter);
 
 
typedef struct dnp3_analog_input_t dnp3_analog_input_t;
 
typedef struct dnp3_analog_input_t
{
    uint16_t index;
    double value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_analog_input_t;
 
static dnp3_analog_input_t dnp3_analog_input_init(uint16_t index, double value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    dnp3_analog_input_t _return_value = {
        index,
        value,
        flags,
        time
    };
    return _return_value;
}
 
 
typedef struct dnp3_analog_input_iterator_t dnp3_analog_input_iterator_t;
 
dnp3_analog_input_t* dnp3_analog_input_iterator_next(dnp3_analog_input_iterator_t* iter);
 
 
typedef struct dnp3_analog_output_status_t dnp3_analog_output_status_t;
 
typedef struct dnp3_analog_output_status_t
{
    uint16_t index;
    double value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_analog_output_status_t;
 
static dnp3_analog_output_status_t dnp3_analog_output_status_init(uint16_t index, double value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    dnp3_analog_output_status_t _return_value = {
        index,
        value,
        flags,
        time
    };
    return _return_value;
}
 
 
typedef struct dnp3_analog_output_status_iterator_t dnp3_analog_output_status_iterator_t;
 
dnp3_analog_output_status_t* dnp3_analog_output_status_iterator_next(dnp3_analog_output_status_iterator_t* iter);
 
 
typedef struct dnp3_byte_iterator_t dnp3_byte_iterator_t;
 
uint8_t* dnp3_byte_iterator_next(dnp3_byte_iterator_t* iter);
 
 
typedef struct dnp3_octet_string_t dnp3_octet_string_t;
 
typedef struct dnp3_octet_string_t
{
    uint16_t index;
    dnp3_byte_iterator_t* value;
} dnp3_octet_string_t;
 
 
typedef struct dnp3_octet_string_iterator_t dnp3_octet_string_iterator_t;
 
dnp3_octet_string_t* dnp3_octet_string_iterator_next(dnp3_octet_string_iterator_t* iter);
 
 
typedef enum dnp3_port_state_t
{
    DNP3_PORT_STATE_DISABLED = 0,
    DNP3_PORT_STATE_WAIT = 1,
    DNP3_PORT_STATE_OPEN = 2,
    DNP3_PORT_STATE_SHUTDOWN = 3,
} dnp3_port_state_t;
 
static const char* dnp3_port_state_to_string(dnp3_port_state_t value)
{
    switch (value)
    {
        case DNP3_PORT_STATE_DISABLED: return "disabled";
        case DNP3_PORT_STATE_WAIT: return "wait";
        case DNP3_PORT_STATE_OPEN: return "open";
        case DNP3_PORT_STATE_SHUTDOWN: return "shutdown";
        default: return "unknown port_state value";
    }
}
 
typedef struct dnp3_port_state_listener_t
{
    
    void (*on_change)(dnp3_port_state_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_port_state_listener_t;
 
static dnp3_port_state_listener_t dnp3_port_state_listener_init(
    void (*on_change)(dnp3_port_state_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_port_state_listener_t _return_value = {
        on_change,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
typedef enum dnp3_variation_t
{
    DNP3_VARIATION_GROUP1_VAR0 = 0,
    DNP3_VARIATION_GROUP1_VAR1 = 1,
    DNP3_VARIATION_GROUP1_VAR2 = 2,
    DNP3_VARIATION_GROUP2_VAR0 = 3,
    DNP3_VARIATION_GROUP2_VAR1 = 4,
    DNP3_VARIATION_GROUP2_VAR2 = 5,
    DNP3_VARIATION_GROUP2_VAR3 = 6,
    DNP3_VARIATION_GROUP3_VAR0 = 7,
    DNP3_VARIATION_GROUP3_VAR1 = 8,
    DNP3_VARIATION_GROUP3_VAR2 = 9,
    DNP3_VARIATION_GROUP4_VAR0 = 10,
    DNP3_VARIATION_GROUP4_VAR1 = 11,
    DNP3_VARIATION_GROUP4_VAR2 = 12,
    DNP3_VARIATION_GROUP4_VAR3 = 13,
    DNP3_VARIATION_GROUP10_VAR0 = 14,
    DNP3_VARIATION_GROUP10_VAR1 = 15,
    DNP3_VARIATION_GROUP10_VAR2 = 16,
    DNP3_VARIATION_GROUP11_VAR0 = 17,
    DNP3_VARIATION_GROUP11_VAR1 = 18,
    DNP3_VARIATION_GROUP11_VAR2 = 19,
    DNP3_VARIATION_GROUP12_VAR0 = 20,
    DNP3_VARIATION_GROUP12_VAR1 = 21,
    DNP3_VARIATION_GROUP20_VAR0 = 22,
    DNP3_VARIATION_GROUP20_VAR1 = 23,
    DNP3_VARIATION_GROUP20_VAR2 = 24,
    DNP3_VARIATION_GROUP20_VAR5 = 25,
    DNP3_VARIATION_GROUP20_VAR6 = 26,
    DNP3_VARIATION_GROUP21_VAR0 = 27,
    DNP3_VARIATION_GROUP21_VAR1 = 28,
    DNP3_VARIATION_GROUP21_VAR2 = 29,
    DNP3_VARIATION_GROUP21_VAR5 = 30,
    DNP3_VARIATION_GROUP21_VAR6 = 31,
    DNP3_VARIATION_GROUP21_VAR9 = 32,
    DNP3_VARIATION_GROUP21_VAR10 = 33,
    DNP3_VARIATION_GROUP22_VAR0 = 34,
    DNP3_VARIATION_GROUP22_VAR1 = 35,
    DNP3_VARIATION_GROUP22_VAR2 = 36,
    DNP3_VARIATION_GROUP22_VAR5 = 37,
    DNP3_VARIATION_GROUP22_VAR6 = 38,
    DNP3_VARIATION_GROUP23_VAR0 = 39,
    DNP3_VARIATION_GROUP23_VAR1 = 40,
    DNP3_VARIATION_GROUP23_VAR2 = 41,
    DNP3_VARIATION_GROUP23_VAR5 = 42,
    DNP3_VARIATION_GROUP23_VAR6 = 43,
    DNP3_VARIATION_GROUP30_VAR0 = 44,
    DNP3_VARIATION_GROUP30_VAR1 = 45,
    DNP3_VARIATION_GROUP30_VAR2 = 46,
    DNP3_VARIATION_GROUP30_VAR3 = 47,
    DNP3_VARIATION_GROUP30_VAR4 = 48,
    DNP3_VARIATION_GROUP30_VAR5 = 49,
    DNP3_VARIATION_GROUP30_VAR6 = 50,
    DNP3_VARIATION_GROUP32_VAR0 = 51,
    DNP3_VARIATION_GROUP32_VAR1 = 52,
    DNP3_VARIATION_GROUP32_VAR2 = 53,
    DNP3_VARIATION_GROUP32_VAR3 = 54,
    DNP3_VARIATION_GROUP32_VAR4 = 55,
    DNP3_VARIATION_GROUP32_VAR5 = 56,
    DNP3_VARIATION_GROUP32_VAR6 = 57,
    DNP3_VARIATION_GROUP32_VAR7 = 58,
    DNP3_VARIATION_GROUP32_VAR8 = 59,
    DNP3_VARIATION_GROUP40_VAR0 = 60,
    DNP3_VARIATION_GROUP40_VAR1 = 61,
    DNP3_VARIATION_GROUP40_VAR2 = 62,
    DNP3_VARIATION_GROUP40_VAR3 = 63,
    DNP3_VARIATION_GROUP40_VAR4 = 64,
    DNP3_VARIATION_GROUP41_VAR0 = 65,
    DNP3_VARIATION_GROUP41_VAR1 = 66,
    DNP3_VARIATION_GROUP41_VAR2 = 67,
    DNP3_VARIATION_GROUP41_VAR3 = 68,
    DNP3_VARIATION_GROUP41_VAR4 = 69,
    DNP3_VARIATION_GROUP42_VAR0 = 70,
    DNP3_VARIATION_GROUP42_VAR1 = 71,
    DNP3_VARIATION_GROUP42_VAR2 = 72,
    DNP3_VARIATION_GROUP42_VAR3 = 73,
    DNP3_VARIATION_GROUP42_VAR4 = 74,
    DNP3_VARIATION_GROUP42_VAR5 = 75,
    DNP3_VARIATION_GROUP42_VAR6 = 76,
    DNP3_VARIATION_GROUP42_VAR7 = 77,
    DNP3_VARIATION_GROUP42_VAR8 = 78,
    DNP3_VARIATION_GROUP50_VAR1 = 79,
    DNP3_VARIATION_GROUP50_VAR3 = 80,
    DNP3_VARIATION_GROUP50_VAR4 = 81,
    DNP3_VARIATION_GROUP51_VAR1 = 82,
    DNP3_VARIATION_GROUP51_VAR2 = 83,
    DNP3_VARIATION_GROUP52_VAR1 = 84,
    DNP3_VARIATION_GROUP52_VAR2 = 85,
    DNP3_VARIATION_GROUP60_VAR1 = 86,
    DNP3_VARIATION_GROUP60_VAR2 = 87,
    DNP3_VARIATION_GROUP60_VAR3 = 88,
    DNP3_VARIATION_GROUP60_VAR4 = 89,
    DNP3_VARIATION_GROUP80_VAR1 = 90,
    DNP3_VARIATION_GROUP110 = 91,
    DNP3_VARIATION_GROUP111 = 92,
} dnp3_variation_t;
 
static const char* dnp3_variation_to_string(dnp3_variation_t value)
{
    switch (value)
    {
        case DNP3_VARIATION_GROUP1_VAR0: return "group1_var0";
        case DNP3_VARIATION_GROUP1_VAR1: return "group1_var1";
        case DNP3_VARIATION_GROUP1_VAR2: return "group1_var2";
        case DNP3_VARIATION_GROUP2_VAR0: return "group2_var0";
        case DNP3_VARIATION_GROUP2_VAR1: return "group2_var1";
        case DNP3_VARIATION_GROUP2_VAR2: return "group2_var2";
        case DNP3_VARIATION_GROUP2_VAR3: return "group2_var3";
        case DNP3_VARIATION_GROUP3_VAR0: return "group3_var0";
        case DNP3_VARIATION_GROUP3_VAR1: return "group3_var1";
        case DNP3_VARIATION_GROUP3_VAR2: return "group3_var2";
        case DNP3_VARIATION_GROUP4_VAR0: return "group4_var0";
        case DNP3_VARIATION_GROUP4_VAR1: return "group4_var1";
        case DNP3_VARIATION_GROUP4_VAR2: return "group4_var2";
        case DNP3_VARIATION_GROUP4_VAR3: return "group4_var3";
        case DNP3_VARIATION_GROUP10_VAR0: return "group10_var0";
        case DNP3_VARIATION_GROUP10_VAR1: return "group10_var1";
        case DNP3_VARIATION_GROUP10_VAR2: return "group10_var2";
        case DNP3_VARIATION_GROUP11_VAR0: return "group11_var0";
        case DNP3_VARIATION_GROUP11_VAR1: return "group11_var1";
        case DNP3_VARIATION_GROUP11_VAR2: return "group11_var2";
        case DNP3_VARIATION_GROUP12_VAR0: return "group12_var0";
        case DNP3_VARIATION_GROUP12_VAR1: return "group12_var1";
        case DNP3_VARIATION_GROUP20_VAR0: return "group20_var0";
        case DNP3_VARIATION_GROUP20_VAR1: return "group20_var1";
        case DNP3_VARIATION_GROUP20_VAR2: return "group20_var2";
        case DNP3_VARIATION_GROUP20_VAR5: return "group20_var5";
        case DNP3_VARIATION_GROUP20_VAR6: return "group20_var6";
        case DNP3_VARIATION_GROUP21_VAR0: return "group21_var0";
        case DNP3_VARIATION_GROUP21_VAR1: return "group21_var1";
        case DNP3_VARIATION_GROUP21_VAR2: return "group21_var2";
        case DNP3_VARIATION_GROUP21_VAR5: return "group21_var5";
        case DNP3_VARIATION_GROUP21_VAR6: return "group21_var6";
        case DNP3_VARIATION_GROUP21_VAR9: return "group21_var9";
        case DNP3_VARIATION_GROUP21_VAR10: return "group21_var10";
        case DNP3_VARIATION_GROUP22_VAR0: return "group22_var0";
        case DNP3_VARIATION_GROUP22_VAR1: return "group22_var1";
        case DNP3_VARIATION_GROUP22_VAR2: return "group22_var2";
        case DNP3_VARIATION_GROUP22_VAR5: return "group22_var5";
        case DNP3_VARIATION_GROUP22_VAR6: return "group22_var6";
        case DNP3_VARIATION_GROUP23_VAR0: return "group23_var0";
        case DNP3_VARIATION_GROUP23_VAR1: return "group23_var1";
        case DNP3_VARIATION_GROUP23_VAR2: return "group23_var2";
        case DNP3_VARIATION_GROUP23_VAR5: return "group23_var5";
        case DNP3_VARIATION_GROUP23_VAR6: return "group23_var6";
        case DNP3_VARIATION_GROUP30_VAR0: return "group30_var0";
        case DNP3_VARIATION_GROUP30_VAR1: return "group30_var1";
        case DNP3_VARIATION_GROUP30_VAR2: return "group30_var2";
        case DNP3_VARIATION_GROUP30_VAR3: return "group30_var3";
        case DNP3_VARIATION_GROUP30_VAR4: return "group30_var4";
        case DNP3_VARIATION_GROUP30_VAR5: return "group30_var5";
        case DNP3_VARIATION_GROUP30_VAR6: return "group30_var6";
        case DNP3_VARIATION_GROUP32_VAR0: return "group32_var0";
        case DNP3_VARIATION_GROUP32_VAR1: return "group32_var1";
        case DNP3_VARIATION_GROUP32_VAR2: return "group32_var2";
        case DNP3_VARIATION_GROUP32_VAR3: return "group32_var3";
        case DNP3_VARIATION_GROUP32_VAR4: return "group32_var4";
        case DNP3_VARIATION_GROUP32_VAR5: return "group32_var5";
        case DNP3_VARIATION_GROUP32_VAR6: return "group32_var6";
        case DNP3_VARIATION_GROUP32_VAR7: return "group32_var7";
        case DNP3_VARIATION_GROUP32_VAR8: return "group32_var8";
        case DNP3_VARIATION_GROUP40_VAR0: return "group40_var0";
        case DNP3_VARIATION_GROUP40_VAR1: return "group40_var1";
        case DNP3_VARIATION_GROUP40_VAR2: return "group40_var2";
        case DNP3_VARIATION_GROUP40_VAR3: return "group40_var3";
        case DNP3_VARIATION_GROUP40_VAR4: return "group40_var4";
        case DNP3_VARIATION_GROUP41_VAR0: return "group41_var0";
        case DNP3_VARIATION_GROUP41_VAR1: return "group41_var1";
        case DNP3_VARIATION_GROUP41_VAR2: return "group41_var2";
        case DNP3_VARIATION_GROUP41_VAR3: return "group41_var3";
        case DNP3_VARIATION_GROUP41_VAR4: return "group41_var4";
        case DNP3_VARIATION_GROUP42_VAR0: return "group42_var0";
        case DNP3_VARIATION_GROUP42_VAR1: return "group42_var1";
        case DNP3_VARIATION_GROUP42_VAR2: return "group42_var2";
        case DNP3_VARIATION_GROUP42_VAR3: return "group42_var3";
        case DNP3_VARIATION_GROUP42_VAR4: return "group42_var4";
        case DNP3_VARIATION_GROUP42_VAR5: return "group42_var5";
        case DNP3_VARIATION_GROUP42_VAR6: return "group42_var6";
        case DNP3_VARIATION_GROUP42_VAR7: return "group42_var7";
        case DNP3_VARIATION_GROUP42_VAR8: return "group42_var8";
        case DNP3_VARIATION_GROUP50_VAR1: return "group50_var1";
        case DNP3_VARIATION_GROUP50_VAR3: return "group50_var3";
        case DNP3_VARIATION_GROUP50_VAR4: return "group50_var4";
        case DNP3_VARIATION_GROUP51_VAR1: return "group51_var1";
        case DNP3_VARIATION_GROUP51_VAR2: return "group51_var2";
        case DNP3_VARIATION_GROUP52_VAR1: return "group52_var1";
        case DNP3_VARIATION_GROUP52_VAR2: return "group52_var2";
        case DNP3_VARIATION_GROUP60_VAR1: return "group60_var1";
        case DNP3_VARIATION_GROUP60_VAR2: return "group60_var2";
        case DNP3_VARIATION_GROUP60_VAR3: return "group60_var3";
        case DNP3_VARIATION_GROUP60_VAR4: return "group60_var4";
        case DNP3_VARIATION_GROUP80_VAR1: return "group80_var1";
        case DNP3_VARIATION_GROUP110: return "group110";
        case DNP3_VARIATION_GROUP111: return "group111";
        default: return "unknown variation value";
    }
}
 
typedef struct dnp3_retry_strategy_t dnp3_retry_strategy_t;
 
typedef struct dnp3_retry_strategy_t
{
    uint64_t min_delay;
    uint64_t max_delay;
} dnp3_retry_strategy_t;
 
static dnp3_retry_strategy_t dnp3_retry_strategy_init()
{
    dnp3_retry_strategy_t _return_value = {
        1000,
        10000
    };
    return _return_value;
}
 
 
typedef enum dnp3_data_bits_t
{
    DNP3_DATA_BITS_FIVE = 0,
    DNP3_DATA_BITS_SIX = 1,
    DNP3_DATA_BITS_SEVEN = 2,
    DNP3_DATA_BITS_EIGHT = 3,
} dnp3_data_bits_t;
 
static const char* dnp3_data_bits_to_string(dnp3_data_bits_t value)
{
    switch (value)
    {
        case DNP3_DATA_BITS_FIVE: return "five";
        case DNP3_DATA_BITS_SIX: return "six";
        case DNP3_DATA_BITS_SEVEN: return "seven";
        case DNP3_DATA_BITS_EIGHT: return "eight";
        default: return "unknown data_bits value";
    }
}
 
typedef enum dnp3_flow_control_t
{
    DNP3_FLOW_CONTROL_NONE = 0,
    DNP3_FLOW_CONTROL_SOFTWARE = 1,
    DNP3_FLOW_CONTROL_HARDWARE = 2,
} dnp3_flow_control_t;
 
static const char* dnp3_flow_control_to_string(dnp3_flow_control_t value)
{
    switch (value)
    {
        case DNP3_FLOW_CONTROL_NONE: return "none";
        case DNP3_FLOW_CONTROL_SOFTWARE: return "software";
        case DNP3_FLOW_CONTROL_HARDWARE: return "hardware";
        default: return "unknown flow_control value";
    }
}
 
typedef enum dnp3_parity_t
{
    DNP3_PARITY_NONE = 0,
    DNP3_PARITY_ODD = 1,
    DNP3_PARITY_EVEN = 2,
} dnp3_parity_t;
 
static const char* dnp3_parity_to_string(dnp3_parity_t value)
{
    switch (value)
    {
        case DNP3_PARITY_NONE: return "none";
        case DNP3_PARITY_ODD: return "odd";
        case DNP3_PARITY_EVEN: return "even";
        default: return "unknown parity value";
    }
}
 
typedef enum dnp3_stop_bits_t
{
    DNP3_STOP_BITS_ONE = 0,
    DNP3_STOP_BITS_TWO = 1,
} dnp3_stop_bits_t;
 
static const char* dnp3_stop_bits_to_string(dnp3_stop_bits_t value)
{
    switch (value)
    {
        case DNP3_STOP_BITS_ONE: return "one";
        case DNP3_STOP_BITS_TWO: return "two";
        default: return "unknown stop_bits value";
    }
}
 
typedef struct dnp3_serial_settings_t dnp3_serial_settings_t;
 
typedef struct dnp3_serial_settings_t
{
    uint32_t baud_rate;
    dnp3_data_bits_t data_bits;
    dnp3_flow_control_t flow_control;
    dnp3_parity_t parity;
    dnp3_stop_bits_t stop_bits;
} dnp3_serial_settings_t;
 
static dnp3_serial_settings_t dnp3_serial_settings_init()
{
    dnp3_serial_settings_t _return_value = {
        9600,
        DNP3_DATA_BITS_EIGHT,
        DNP3_FLOW_CONTROL_NONE,
        DNP3_PARITY_NONE,
        DNP3_STOP_BITS_ONE
    };
    return _return_value;
}
 
 
typedef enum dnp3_link_error_mode_t
{
    DNP3_LINK_ERROR_MODE_DISCARD = 0,
    DNP3_LINK_ERROR_MODE_CLOSE = 1,
} dnp3_link_error_mode_t;
 
static const char* dnp3_link_error_mode_to_string(dnp3_link_error_mode_t value)
{
    switch (value)
    {
        case DNP3_LINK_ERROR_MODE_DISCARD: return "discard";
        case DNP3_LINK_ERROR_MODE_CLOSE: return "close";
        default: return "unknown link_error_mode value";
    }
}
 
typedef enum dnp3_min_tls_version_t
{
    DNP3_MIN_TLS_VERSION_V12 = 0,
    DNP3_MIN_TLS_VERSION_V13 = 1,
} dnp3_min_tls_version_t;
 
static const char* dnp3_min_tls_version_to_string(dnp3_min_tls_version_t value)
{
    switch (value)
    {
        case DNP3_MIN_TLS_VERSION_V12: return "v12";
        case DNP3_MIN_TLS_VERSION_V13: return "v13";
        default: return "unknown min_tls_version value";
    }
}
 
typedef enum dnp3_certificate_mode_t
{
    DNP3_CERTIFICATE_MODE_AUTHORITY_BASED = 0,
    DNP3_CERTIFICATE_MODE_SELF_SIGNED = 1,
} dnp3_certificate_mode_t;
 
static const char* dnp3_certificate_mode_to_string(dnp3_certificate_mode_t value)
{
    switch (value)
    {
        case DNP3_CERTIFICATE_MODE_AUTHORITY_BASED: return "authority_based";
        case DNP3_CERTIFICATE_MODE_SELF_SIGNED: return "self_signed";
        default: return "unknown certificate_mode value";
    }
}
 
typedef enum dnp3_function_code_t
{
    DNP3_FUNCTION_CODE_CONFIRM = 0,
    DNP3_FUNCTION_CODE_READ = 1,
    DNP3_FUNCTION_CODE_WRITE = 2,
    DNP3_FUNCTION_CODE_SELECT = 3,
    DNP3_FUNCTION_CODE_OPERATE = 4,
    DNP3_FUNCTION_CODE_DIRECT_OPERATE = 5,
    DNP3_FUNCTION_CODE_DIRECT_OPERATE_NO_RESPONSE = 6,
    DNP3_FUNCTION_CODE_IMMEDIATE_FREEZE = 7,
    DNP3_FUNCTION_CODE_IMMEDIATE_FREEZE_NO_RESPONSE = 8,
    DNP3_FUNCTION_CODE_FREEZE_CLEAR = 9,
    DNP3_FUNCTION_CODE_FREEZE_CLEAR_NO_RESPONSE = 10,
    DNP3_FUNCTION_CODE_FREEZE_AT_TIME = 11,
    DNP3_FUNCTION_CODE_FREEZE_AT_TIME_NO_RESPONSE = 12,
    DNP3_FUNCTION_CODE_COLD_RESTART = 13,
    DNP3_FUNCTION_CODE_WARM_RESTART = 14,
    DNP3_FUNCTION_CODE_INITIALIZE_DATA = 15,
    DNP3_FUNCTION_CODE_INITIALIZE_APPLICATION = 16,
    DNP3_FUNCTION_CODE_START_APPLICATION = 17,
    DNP3_FUNCTION_CODE_STOP_APPLICATION = 18,
    DNP3_FUNCTION_CODE_SAVE_CONFIGURATION = 19,
    DNP3_FUNCTION_CODE_ENABLE_UNSOLICITED = 20,
    DNP3_FUNCTION_CODE_DISABLE_UNSOLICITED = 21,
    DNP3_FUNCTION_CODE_ASSIGN_CLASS = 22,
    DNP3_FUNCTION_CODE_DELAY_MEASURE = 23,
    DNP3_FUNCTION_CODE_RECORD_CURRENT_TIME = 24,
    DNP3_FUNCTION_CODE_OPEN_FILE = 25,
    DNP3_FUNCTION_CODE_CLOSE_FILE = 26,
    DNP3_FUNCTION_CODE_DELETE_FILE = 27,
    DNP3_FUNCTION_CODE_GET_FILE_INFO = 28,
    DNP3_FUNCTION_CODE_AUTHENTICATE_FILE = 29,
    DNP3_FUNCTION_CODE_ABORT_FILE = 30,
    DNP3_FUNCTION_CODE_RESPONSE = 31,
    DNP3_FUNCTION_CODE_UNSOLICITED_RESPONSE = 32,
} dnp3_function_code_t;
 
static const char* dnp3_function_code_to_string(dnp3_function_code_t value)
{
    switch (value)
    {
        case DNP3_FUNCTION_CODE_CONFIRM: return "confirm";
        case DNP3_FUNCTION_CODE_READ: return "read";
        case DNP3_FUNCTION_CODE_WRITE: return "write";
        case DNP3_FUNCTION_CODE_SELECT: return "select";
        case DNP3_FUNCTION_CODE_OPERATE: return "operate";
        case DNP3_FUNCTION_CODE_DIRECT_OPERATE: return "direct_operate";
        case DNP3_FUNCTION_CODE_DIRECT_OPERATE_NO_RESPONSE: return "direct_operate_no_response";
        case DNP3_FUNCTION_CODE_IMMEDIATE_FREEZE: return "immediate_freeze";
        case DNP3_FUNCTION_CODE_IMMEDIATE_FREEZE_NO_RESPONSE: return "immediate_freeze_no_response";
        case DNP3_FUNCTION_CODE_FREEZE_CLEAR: return "freeze_clear";
        case DNP3_FUNCTION_CODE_FREEZE_CLEAR_NO_RESPONSE: return "freeze_clear_no_response";
        case DNP3_FUNCTION_CODE_FREEZE_AT_TIME: return "freeze_at_time";
        case DNP3_FUNCTION_CODE_FREEZE_AT_TIME_NO_RESPONSE: return "freeze_at_time_no_response";
        case DNP3_FUNCTION_CODE_COLD_RESTART: return "cold_restart";
        case DNP3_FUNCTION_CODE_WARM_RESTART: return "warm_restart";
        case DNP3_FUNCTION_CODE_INITIALIZE_DATA: return "initialize_data";
        case DNP3_FUNCTION_CODE_INITIALIZE_APPLICATION: return "initialize_application";
        case DNP3_FUNCTION_CODE_START_APPLICATION: return "start_application";
        case DNP3_FUNCTION_CODE_STOP_APPLICATION: return "stop_application";
        case DNP3_FUNCTION_CODE_SAVE_CONFIGURATION: return "save_configuration";
        case DNP3_FUNCTION_CODE_ENABLE_UNSOLICITED: return "enable_unsolicited";
        case DNP3_FUNCTION_CODE_DISABLE_UNSOLICITED: return "disable_unsolicited";
        case DNP3_FUNCTION_CODE_ASSIGN_CLASS: return "assign_class";
        case DNP3_FUNCTION_CODE_DELAY_MEASURE: return "delay_measure";
        case DNP3_FUNCTION_CODE_RECORD_CURRENT_TIME: return "record_current_time";
        case DNP3_FUNCTION_CODE_OPEN_FILE: return "open_file";
        case DNP3_FUNCTION_CODE_CLOSE_FILE: return "close_file";
        case DNP3_FUNCTION_CODE_DELETE_FILE: return "delete_file";
        case DNP3_FUNCTION_CODE_GET_FILE_INFO: return "get_file_info";
        case DNP3_FUNCTION_CODE_AUTHENTICATE_FILE: return "authenticate_file";
        case DNP3_FUNCTION_CODE_ABORT_FILE: return "abort_file";
        case DNP3_FUNCTION_CODE_RESPONSE: return "response";
        case DNP3_FUNCTION_CODE_UNSOLICITED_RESPONSE: return "unsolicited_response";
        default: return "unknown function_code value";
    }
}
 
typedef enum dnp3_response_function_t
{
    DNP3_RESPONSE_FUNCTION_RESPONSE = 0,
    DNP3_RESPONSE_FUNCTION_UNSOLICITED_RESPONSE = 1,
} dnp3_response_function_t;
 
static const char* dnp3_response_function_to_string(dnp3_response_function_t value)
{
    switch (value)
    {
        case DNP3_RESPONSE_FUNCTION_RESPONSE: return "response";
        case DNP3_RESPONSE_FUNCTION_UNSOLICITED_RESPONSE: return "unsolicited_response";
        default: return "unknown response_function value";
    }
}
 
typedef struct dnp3_iin1_t dnp3_iin1_t;
 
typedef struct dnp3_iin1_t
{
    bool broadcast;
    bool class_1_events;
    bool class_2_events;
    bool class_3_events;
    bool need_time;
    bool local_control;
    bool device_trouble;
    bool device_restart;
} dnp3_iin1_t;
 
 
typedef struct dnp3_iin2_t dnp3_iin2_t;
 
typedef struct dnp3_iin2_t
{
    bool no_func_code_support;
    bool object_unknown;
    bool parameter_error;
    bool event_buffer_overflow;
    bool already_executing;
    bool config_corrupt;
    bool reserved_2;
    bool reserved_1;
} dnp3_iin2_t;
 
 
typedef struct dnp3_iin_t dnp3_iin_t;
 
typedef struct dnp3_iin_t
{
    dnp3_iin1_t iin1;
    dnp3_iin2_t iin2;
} dnp3_iin_t;
 
 
typedef struct dnp3_response_header_t dnp3_response_header_t;
 
typedef struct dnp3_response_header_t
{
    dnp3_control_field_t control_field;
    dnp3_response_function_t func;
    dnp3_iin_t iin;
} dnp3_response_header_t;
 
 
typedef enum dnp3_qualifier_code_t
{
    DNP3_QUALIFIER_CODE_RANGE8 = 0,
    DNP3_QUALIFIER_CODE_RANGE16 = 1,
    DNP3_QUALIFIER_CODE_ALL_OBJECTS = 2,
    DNP3_QUALIFIER_CODE_COUNT8 = 3,
    DNP3_QUALIFIER_CODE_COUNT16 = 4,
    DNP3_QUALIFIER_CODE_COUNT_AND_PREFIX_8 = 5,
    DNP3_QUALIFIER_CODE_COUNT_AND_PREFIX_16 = 6,
    DNP3_QUALIFIER_CODE_FREE_FORMAT_16 = 7,
} dnp3_qualifier_code_t;
 
static const char* dnp3_qualifier_code_to_string(dnp3_qualifier_code_t value)
{
    switch (value)
    {
        case DNP3_QUALIFIER_CODE_RANGE8: return "range8";
        case DNP3_QUALIFIER_CODE_RANGE16: return "range16";
        case DNP3_QUALIFIER_CODE_ALL_OBJECTS: return "all_objects";
        case DNP3_QUALIFIER_CODE_COUNT8: return "count8";
        case DNP3_QUALIFIER_CODE_COUNT16: return "count16";
        case DNP3_QUALIFIER_CODE_COUNT_AND_PREFIX_8: return "count_and_prefix_8";
        case DNP3_QUALIFIER_CODE_COUNT_AND_PREFIX_16: return "count_and_prefix_16";
        case DNP3_QUALIFIER_CODE_FREE_FORMAT_16: return "free_format_16";
        default: return "unknown qualifier_code value";
    }
}
 
typedef struct dnp3_header_info_t dnp3_header_info_t;
 
typedef struct dnp3_header_info_t
{
    dnp3_variation_t variation;
    dnp3_qualifier_code_t qualifier;
    bool is_event;
    bool has_flags;
} dnp3_header_info_t;
 
 
typedef enum dnp3_read_type_t
{
    DNP3_READ_TYPE_STARTUP_INTEGRITY = 0,
    DNP3_READ_TYPE_UNSOLICITED = 1,
    DNP3_READ_TYPE_SINGLE_POLL = 2,
    DNP3_READ_TYPE_PERIODIC_POLL = 3,
} dnp3_read_type_t;
 
static const char* dnp3_read_type_to_string(dnp3_read_type_t value)
{
    switch (value)
    {
        case DNP3_READ_TYPE_STARTUP_INTEGRITY: return "startup_integrity";
        case DNP3_READ_TYPE_UNSOLICITED: return "unsolicited";
        case DNP3_READ_TYPE_SINGLE_POLL: return "single_poll";
        case DNP3_READ_TYPE_PERIODIC_POLL: return "periodic_poll";
        default: return "unknown read_type value";
    }
}
 
typedef struct dnp3_read_handler_t
{
    
    void (*begin_fragment)(dnp3_read_type_t, dnp3_response_header_t, void*);
    
    void (*end_fragment)(dnp3_read_type_t, dnp3_response_header_t, void*);
    
    void (*handle_binary_input)(dnp3_header_info_t, dnp3_binary_input_iterator_t*, void*);
    
    void (*handle_double_bit_binary_input)(dnp3_header_info_t, dnp3_double_bit_binary_input_iterator_t*, void*);
    
    void (*handle_binary_output_status)(dnp3_header_info_t, dnp3_binary_output_status_iterator_t*, void*);
    
    void (*handle_counter)(dnp3_header_info_t, dnp3_counter_iterator_t*, void*);
    
    void (*handle_frozen_counter)(dnp3_header_info_t, dnp3_frozen_counter_iterator_t*, void*);
    
    void (*handle_analog_input)(dnp3_header_info_t, dnp3_analog_input_iterator_t*, void*);
    
    void (*handle_analog_output_status)(dnp3_header_info_t, dnp3_analog_output_status_iterator_t*, void*);
    
    void (*handle_octet_string)(dnp3_header_info_t, dnp3_octet_string_iterator_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_read_handler_t;
 
static dnp3_read_handler_t dnp3_read_handler_init(
    void (*begin_fragment)(dnp3_read_type_t, dnp3_response_header_t, void*),
    void (*end_fragment)(dnp3_read_type_t, dnp3_response_header_t, void*),
    void (*handle_binary_input)(dnp3_header_info_t, dnp3_binary_input_iterator_t*, void*),
    void (*handle_double_bit_binary_input)(dnp3_header_info_t, dnp3_double_bit_binary_input_iterator_t*, void*),
    void (*handle_binary_output_status)(dnp3_header_info_t, dnp3_binary_output_status_iterator_t*, void*),
    void (*handle_counter)(dnp3_header_info_t, dnp3_counter_iterator_t*, void*),
    void (*handle_frozen_counter)(dnp3_header_info_t, dnp3_frozen_counter_iterator_t*, void*),
    void (*handle_analog_input)(dnp3_header_info_t, dnp3_analog_input_iterator_t*, void*),
    void (*handle_analog_output_status)(dnp3_header_info_t, dnp3_analog_output_status_iterator_t*, void*),
    void (*handle_octet_string)(dnp3_header_info_t, dnp3_octet_string_iterator_t*, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_read_handler_t _return_value = {
        begin_fragment,
        end_fragment,
        handle_binary_input,
        handle_double_bit_binary_input,
        handle_binary_output_status,
        handle_counter,
        handle_frozen_counter,
        handle_analog_input,
        handle_analog_output_status,
        handle_octet_string,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
typedef struct dnp3_endpoint_list_t dnp3_endpoint_list_t;
 
dnp3_endpoint_list_t* dnp3_endpoint_list_create(const char* main_endpoint);
 
void dnp3_endpoint_list_destroy(dnp3_endpoint_list_t* instance);
 
void dnp3_endpoint_list_add(dnp3_endpoint_list_t* instance, const char* endpoint);
 
 
typedef struct dnp3_master_channel_config_t dnp3_master_channel_config_t;
 
typedef struct dnp3_master_channel_config_t
{
    uint16_t address;
    dnp3_decode_level_t decode_level;
    uint16_t tx_buffer_size;
    uint16_t rx_buffer_size;
} dnp3_master_channel_config_t;
 
static dnp3_master_channel_config_t dnp3_master_channel_config_init(uint16_t address)
{
    dnp3_master_channel_config_t _return_value = {
        address,
        dnp3_decode_level_init(),
        2048,
        2048
    };
    return _return_value;
}
 
 
typedef enum dnp3_client_state_t
{
    DNP3_CLIENT_STATE_DISABLED = 0,
    DNP3_CLIENT_STATE_CONNECTING = 1,
    DNP3_CLIENT_STATE_CONNECTED = 2,
    DNP3_CLIENT_STATE_WAIT_AFTER_FAILED_CONNECT = 3,
    DNP3_CLIENT_STATE_WAIT_AFTER_DISCONNECT = 4,
    DNP3_CLIENT_STATE_SHUTDOWN = 5,
} dnp3_client_state_t;
 
static const char* dnp3_client_state_to_string(dnp3_client_state_t value)
{
    switch (value)
    {
        case DNP3_CLIENT_STATE_DISABLED: return "disabled";
        case DNP3_CLIENT_STATE_CONNECTING: return "connecting";
        case DNP3_CLIENT_STATE_CONNECTED: return "connected";
        case DNP3_CLIENT_STATE_WAIT_AFTER_FAILED_CONNECT: return "wait_after_failed_connect";
        case DNP3_CLIENT_STATE_WAIT_AFTER_DISCONNECT: return "wait_after_disconnect";
        case DNP3_CLIENT_STATE_SHUTDOWN: return "shutdown";
        default: return "unknown client_state value";
    }
}
 
typedef struct dnp3_client_state_listener_t
{
    
    void (*on_change)(dnp3_client_state_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_client_state_listener_t;
 
static dnp3_client_state_listener_t dnp3_client_state_listener_init(
    void (*on_change)(dnp3_client_state_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_client_state_listener_t _return_value = {
        on_change,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
typedef struct dnp3_master_channel_t dnp3_master_channel_t;
 
typedef struct dnp3_tls_client_config_t dnp3_tls_client_config_t;
 
typedef struct dnp3_tls_client_config_t
{
    const char* dns_name;
    const char* peer_cert_path;
    const char* local_cert_path;
    const char* private_key_path;
    const char* password;
    dnp3_min_tls_version_t min_tls_version;
    dnp3_certificate_mode_t certificate_mode;
} dnp3_tls_client_config_t;
 
static dnp3_tls_client_config_t dnp3_tls_client_config_init(const char* dns_name, const char* peer_cert_path, const char* local_cert_path, const char* private_key_path, const char* password)
{
    dnp3_tls_client_config_t _return_value = {
        dns_name,
        peer_cert_path,
        local_cert_path,
        private_key_path,
        password,
        DNP3_MIN_TLS_VERSION_V12,
        DNP3_CERTIFICATE_MODE_AUTHORITY_BASED
    };
    return _return_value;
}
 
 
typedef struct dnp3_connect_strategy_t dnp3_connect_strategy_t;
 
typedef struct dnp3_connect_strategy_t
{
    uint64_t min_connect_delay;
    uint64_t max_connect_delay;
    uint64_t reconnect_delay;
} dnp3_connect_strategy_t;
 
static dnp3_connect_strategy_t dnp3_connect_strategy_init()
{
    dnp3_connect_strategy_t _return_value = {
        1000,
        10000,
        1000
    };
    return _return_value;
}
 
 
typedef enum dnp3_nothing_t
{
    DNP3_NOTHING_NOTHING = 0,
} dnp3_nothing_t;
 
static const char* dnp3_nothing_to_string(dnp3_nothing_t value)
{
    switch (value)
    {
        case DNP3_NOTHING_NOTHING: return "nothing";
        default: return "unknown nothing value";
    }
}
 
dnp3_param_error_t dnp3_master_channel_create_tcp(dnp3_runtime_t* runtime, dnp3_link_error_mode_t link_error_mode, dnp3_master_channel_config_t config, dnp3_endpoint_list_t* endpoints, dnp3_connect_strategy_t connect_strategy, dnp3_client_state_listener_t listener, dnp3_master_channel_t** out);
 
dnp3_param_error_t dnp3_master_channel_create_serial(dnp3_runtime_t* runtime, dnp3_master_channel_config_t config, const char* path, dnp3_serial_settings_t serial_params, uint64_t open_retry_delay, dnp3_port_state_listener_t listener, dnp3_master_channel_t** out);
 
void dnp3_master_channel_destroy(dnp3_master_channel_t* instance);
 
dnp3_param_error_t dnp3_master_channel_create_tls(dnp3_runtime_t* runtime, dnp3_link_error_mode_t link_error_mode, dnp3_master_channel_config_t config, dnp3_endpoint_list_t* endpoints, dnp3_connect_strategy_t connect_strategy, dnp3_client_state_listener_t listener, dnp3_tls_client_config_t tls_config, dnp3_master_channel_t** out);
 
dnp3_param_error_t dnp3_master_channel_enable(dnp3_master_channel_t* instance);
 
dnp3_param_error_t dnp3_master_channel_disable(dnp3_master_channel_t* instance);
 
typedef struct dnp3_association_id_t dnp3_association_id_t;
 
typedef struct dnp3_association_id_t
{
    uint16_t address;
} dnp3_association_id_t;
 
typedef struct dnp3_poll_id_t dnp3_poll_id_t;
 
typedef struct dnp3_poll_id_t
{
    uint16_t association_id;
    uint64_t id;
} dnp3_poll_id_t;
 
typedef struct dnp3_event_classes_t dnp3_event_classes_t;
 
typedef struct dnp3_event_classes_t
{
    bool class1;
    bool class2;
    bool class3;
} dnp3_event_classes_t;
 
static dnp3_event_classes_t dnp3_event_classes_init(bool class1, bool class2, bool class3)
{
    dnp3_event_classes_t _return_value = {
        class1,
        class2,
        class3
    };
    return _return_value;
}
 
static dnp3_event_classes_t dnp3_event_classes_all()
{
    dnp3_event_classes_t _return_value = {
        true,
        true,
        true
    };
    return _return_value;
}
 
static dnp3_event_classes_t dnp3_event_classes_none()
{
    dnp3_event_classes_t _return_value = {
        false,
        false,
        false
    };
    return _return_value;
}
 
 
typedef struct dnp3_classes_t dnp3_classes_t;
 
typedef struct dnp3_classes_t
{
    bool class0;
    bool class1;
    bool class2;
    bool class3;
} dnp3_classes_t;
 
static dnp3_classes_t dnp3_classes_init(bool class0, bool class1, bool class2, bool class3)
{
    dnp3_classes_t _return_value = {
        class0,
        class1,
        class2,
        class3
    };
    return _return_value;
}
 
static dnp3_classes_t dnp3_classes_all()
{
    dnp3_classes_t _return_value = {
        true,
        true,
        true,
        true
    };
    return _return_value;
}
 
static dnp3_classes_t dnp3_classes_none()
{
    dnp3_classes_t _return_value = {
        false,
        false,
        false,
        false
    };
    return _return_value;
}
 
 
typedef enum dnp3_auto_time_sync_t
{
    DNP3_AUTO_TIME_SYNC_NONE = 0,
    DNP3_AUTO_TIME_SYNC_LAN = 1,
    DNP3_AUTO_TIME_SYNC_NON_LAN = 2,
} dnp3_auto_time_sync_t;
 
static const char* dnp3_auto_time_sync_to_string(dnp3_auto_time_sync_t value)
{
    switch (value)
    {
        case DNP3_AUTO_TIME_SYNC_NONE: return "none";
        case DNP3_AUTO_TIME_SYNC_LAN: return "lan";
        case DNP3_AUTO_TIME_SYNC_NON_LAN: return "non_lan";
        default: return "unknown auto_time_sync value";
    }
}
 
typedef struct dnp3_association_config_t dnp3_association_config_t;
 
typedef struct dnp3_association_config_t
{
    uint64_t response_timeout;
    dnp3_event_classes_t disable_unsol_classes;
    dnp3_event_classes_t enable_unsol_classes;
    dnp3_classes_t startup_integrity_classes;
    dnp3_auto_time_sync_t auto_time_sync;
    dnp3_retry_strategy_t auto_tasks_retry_strategy;
    uint64_t keep_alive_timeout;
    bool auto_integrity_scan_on_buffer_overflow;
    dnp3_event_classes_t event_scan_on_events_available;
    uint16_t max_queued_user_requests;
} dnp3_association_config_t;
 
static dnp3_association_config_t dnp3_association_config_init(dnp3_event_classes_t disable_unsol_classes, dnp3_event_classes_t enable_unsol_classes, dnp3_classes_t startup_integrity_classes, dnp3_event_classes_t event_scan_on_events_available)
{
    dnp3_association_config_t _return_value = {
        5000,
        disable_unsol_classes,
        enable_unsol_classes,
        startup_integrity_classes,
        DNP3_AUTO_TIME_SYNC_NONE,
        dnp3_retry_strategy_init(),
        60,
        true,
        event_scan_on_events_available,
        16
    };
    return _return_value;
}
 
 
typedef struct dnp3_utc_timestamp_t dnp3_utc_timestamp_t;
 
typedef struct dnp3_utc_timestamp_t
{
    uint64_t value;
    bool is_valid;
} dnp3_utc_timestamp_t;
 
static dnp3_utc_timestamp_t dnp3_utc_timestamp_valid(uint64_t value)
{
    dnp3_utc_timestamp_t _return_value = {
        value,
        true
    };
    return _return_value;
}
 
static dnp3_utc_timestamp_t dnp3_utc_timestamp_invalid()
{
    dnp3_utc_timestamp_t _return_value = {
        0,
        false
    };
    return _return_value;
}
 
 
typedef struct dnp3_association_handler_t
{
    
    dnp3_utc_timestamp_t (*get_current_time)(void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_association_handler_t;
 
static dnp3_association_handler_t dnp3_association_handler_init(
    dnp3_utc_timestamp_t (*get_current_time)(void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_association_handler_t _return_value = {
        get_current_time,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
typedef enum dnp3_task_type_t
{
    DNP3_TASK_TYPE_USER_READ = 0,
    DNP3_TASK_TYPE_PERIODIC_POLL = 1,
    DNP3_TASK_TYPE_STARTUP_INTEGRITY = 2,
    DNP3_TASK_TYPE_AUTO_EVENT_SCAN = 3,
    DNP3_TASK_TYPE_COMMAND = 4,
    DNP3_TASK_TYPE_CLEAR_RESTART_BIT = 5,
    DNP3_TASK_TYPE_ENABLE_UNSOLICITED = 6,
    DNP3_TASK_TYPE_DISABLE_UNSOLICITED = 7,
    DNP3_TASK_TYPE_TIME_SYNC = 8,
    DNP3_TASK_TYPE_RESTART = 9,
} dnp3_task_type_t;
 
static const char* dnp3_task_type_to_string(dnp3_task_type_t value)
{
    switch (value)
    {
        case DNP3_TASK_TYPE_USER_READ: return "user_read";
        case DNP3_TASK_TYPE_PERIODIC_POLL: return "periodic_poll";
        case DNP3_TASK_TYPE_STARTUP_INTEGRITY: return "startup_integrity";
        case DNP3_TASK_TYPE_AUTO_EVENT_SCAN: return "auto_event_scan";
        case DNP3_TASK_TYPE_COMMAND: return "command";
        case DNP3_TASK_TYPE_CLEAR_RESTART_BIT: return "clear_restart_bit";
        case DNP3_TASK_TYPE_ENABLE_UNSOLICITED: return "enable_unsolicited";
        case DNP3_TASK_TYPE_DISABLE_UNSOLICITED: return "disable_unsolicited";
        case DNP3_TASK_TYPE_TIME_SYNC: return "time_sync";
        case DNP3_TASK_TYPE_RESTART: return "restart";
        default: return "unknown task_type value";
    }
}
 
typedef enum dnp3_task_error_t
{
    DNP3_TASK_ERROR_TOO_MANY_REQUESTS = 0,
    DNP3_TASK_ERROR_BAD_RESPONSE = 1,
    DNP3_TASK_ERROR_RESPONSE_TIMEOUT = 2,
    DNP3_TASK_ERROR_WRITE_ERROR = 3,
    DNP3_TASK_ERROR_NO_CONNECTION = 4,
    DNP3_TASK_ERROR_SHUTDOWN = 5,
    DNP3_TASK_ERROR_ASSOCIATION_REMOVED = 6,
} dnp3_task_error_t;
 
static const char* dnp3_task_error_to_string(dnp3_task_error_t value)
{
    switch (value)
    {
        case DNP3_TASK_ERROR_TOO_MANY_REQUESTS: return "too_many_requests";
        case DNP3_TASK_ERROR_BAD_RESPONSE: return "bad_response";
        case DNP3_TASK_ERROR_RESPONSE_TIMEOUT: return "response_timeout";
        case DNP3_TASK_ERROR_WRITE_ERROR: return "write_error";
        case DNP3_TASK_ERROR_NO_CONNECTION: return "no_connection";
        case DNP3_TASK_ERROR_SHUTDOWN: return "shutdown";
        case DNP3_TASK_ERROR_ASSOCIATION_REMOVED: return "association_removed";
        default: return "unknown task_error value";
    }
}
 
typedef struct dnp3_association_information_t
{
    
    void (*task_start)(dnp3_task_type_t, dnp3_function_code_t, uint8_t, void*);
    
    void (*task_success)(dnp3_task_type_t, dnp3_function_code_t, uint8_t, void*);
    
    void (*task_fail)(dnp3_task_type_t, dnp3_task_error_t, void*);
    
    void (*unsolicited_response)(bool, uint8_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_association_information_t;
 
static dnp3_association_information_t dnp3_association_information_init(
    void (*task_start)(dnp3_task_type_t, dnp3_function_code_t, uint8_t, void*),
    void (*task_success)(dnp3_task_type_t, dnp3_function_code_t, uint8_t, void*),
    void (*task_fail)(dnp3_task_type_t, dnp3_task_error_t, void*),
    void (*unsolicited_response)(bool, uint8_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_association_information_t _return_value = {
        task_start,
        task_success,
        task_fail,
        unsolicited_response,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
typedef struct dnp3_request_t dnp3_request_t;
 
dnp3_request_t* dnp3_request_create();
 
dnp3_request_t* dnp3_request_new_class(bool class0, bool class1, bool class2, bool class3);
 
dnp3_request_t* dnp3_request_new_all_objects(dnp3_variation_t variation);
 
dnp3_request_t* dnp3_request_new_one_byte_range(dnp3_variation_t variation, uint8_t start, uint8_t stop);
 
dnp3_request_t* dnp3_request_new_two_byte_range(dnp3_variation_t variation, uint16_t start, uint16_t stop);
 
dnp3_request_t* dnp3_request_new_one_byte_limited_count(dnp3_variation_t variation, uint8_t count);
 
dnp3_request_t* dnp3_request_new_two_byte_limited_count(dnp3_variation_t variation, uint16_t count);
 
void dnp3_request_destroy(dnp3_request_t* instance);
 
void dnp3_request_add_one_byte_range_header(dnp3_request_t* instance, dnp3_variation_t variation, uint8_t start, uint8_t stop);
 
void dnp3_request_add_two_byte_range_header(dnp3_request_t* instance, dnp3_variation_t variation, uint16_t start, uint16_t stop);
 
void dnp3_request_add_all_objects_header(dnp3_request_t* instance, dnp3_variation_t variation);
 
void dnp3_request_add_one_byte_limited_count_header(dnp3_request_t* instance, dnp3_variation_t variation, uint8_t count);
 
void dnp3_request_add_two_byte_limited_count_header(dnp3_request_t* instance, dnp3_variation_t variation, uint16_t count);
 
 
dnp3_param_error_t dnp3_master_channel_add_association(dnp3_master_channel_t* instance, uint16_t address, dnp3_association_config_t config, dnp3_read_handler_t read_handler, dnp3_association_handler_t association_handler, dnp3_association_information_t association_information, dnp3_association_id_t* out);
 
dnp3_param_error_t dnp3_master_channel_remove_association(dnp3_master_channel_t* instance, dnp3_association_id_t id);
 
dnp3_param_error_t dnp3_master_channel_add_poll(dnp3_master_channel_t* instance, dnp3_association_id_t id, dnp3_request_t* request, uint64_t period, dnp3_poll_id_t* out);
 
dnp3_param_error_t dnp3_master_channel_remove_poll(dnp3_master_channel_t* instance, dnp3_poll_id_t poll_id);
 
dnp3_param_error_t dnp3_master_channel_demand_poll(dnp3_master_channel_t* instance, dnp3_poll_id_t poll_id);
 
dnp3_param_error_t dnp3_master_channel_set_decode_level(dnp3_master_channel_t* instance, dnp3_decode_level_t decode_level);
 
dnp3_param_error_t dnp3_master_channel_get_decode_level(dnp3_master_channel_t* instance, dnp3_decode_level_t* out);
 
typedef enum dnp3_read_error_t
{
    DNP3_READ_ERROR_OK = 0,
    DNP3_READ_ERROR_TOO_MANY_REQUESTS = 1,
    DNP3_READ_ERROR_BAD_RESPONSE = 2,
    DNP3_READ_ERROR_RESPONSE_TIMEOUT = 3,
    DNP3_READ_ERROR_WRITE_ERROR = 4,
    DNP3_READ_ERROR_NO_CONNECTION = 5,
    DNP3_READ_ERROR_SHUTDOWN = 6,
    DNP3_READ_ERROR_ASSOCIATION_REMOVED = 7,
} dnp3_read_error_t;
 
static const char* dnp3_read_error_to_string(dnp3_read_error_t value)
{
    switch (value)
    {
        case DNP3_READ_ERROR_OK: return "ok";
        case DNP3_READ_ERROR_TOO_MANY_REQUESTS: return "too_many_requests";
        case DNP3_READ_ERROR_BAD_RESPONSE: return "bad_response";
        case DNP3_READ_ERROR_RESPONSE_TIMEOUT: return "response_timeout";
        case DNP3_READ_ERROR_WRITE_ERROR: return "write_error";
        case DNP3_READ_ERROR_NO_CONNECTION: return "no_connection";
        case DNP3_READ_ERROR_SHUTDOWN: return "shutdown";
        case DNP3_READ_ERROR_ASSOCIATION_REMOVED: return "association_removed";
        default: return "unknown read_error value";
    }
}
 
 
typedef struct dnp3_read_task_callback_t
{
    
    void (*on_complete)(dnp3_nothing_t, void*);
    
    void (*on_failure)(dnp3_read_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_read_task_callback_t;
 
static dnp3_read_task_callback_t dnp3_read_task_callback_init(
    void (*on_complete)(dnp3_nothing_t, void*),
    void (*on_failure)(dnp3_read_error_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_read_task_callback_t _return_value = {
        on_complete,
        on_failure,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
dnp3_param_error_t dnp3_master_channel_read(dnp3_master_channel_t* instance, dnp3_association_id_t association, dnp3_request_t* request, dnp3_read_task_callback_t callback);
 
dnp3_param_error_t dnp3_master_channel_read_with_handler(dnp3_master_channel_t* instance, dnp3_association_id_t association, dnp3_request_t* request, dnp3_read_handler_t handler, dnp3_read_task_callback_t callback);
 
typedef struct dnp3_command_set_t dnp3_command_set_t;
 
dnp3_command_set_t* dnp3_command_set_create();
 
void dnp3_command_set_destroy(dnp3_command_set_t* instance);
 
void dnp3_command_set_finish_header(dnp3_command_set_t* instance);
 
void dnp3_command_set_add_g12_v1_u8(dnp3_command_set_t* instance, uint8_t idx, dnp3_group12_var1_t header);
 
void dnp3_command_set_add_g12_v1_u16(dnp3_command_set_t* instance, uint16_t idx, dnp3_group12_var1_t header);
 
void dnp3_command_set_add_g41_v1_u8(dnp3_command_set_t* instance, uint8_t idx, int32_t value);
 
void dnp3_command_set_add_g41_v1_u16(dnp3_command_set_t* instance, uint16_t idx, int32_t value);
 
void dnp3_command_set_add_g41_v2_u8(dnp3_command_set_t* instance, uint8_t idx, int16_t value);
 
void dnp3_command_set_add_g41_v2_u16(dnp3_command_set_t* instance, uint16_t idx, int16_t value);
 
void dnp3_command_set_add_g41_v3_u8(dnp3_command_set_t* instance, uint8_t idx, float value);
 
void dnp3_command_set_add_g41_v3_u16(dnp3_command_set_t* instance, uint16_t idx, float value);
 
void dnp3_command_set_add_g41_v4_u8(dnp3_command_set_t* instance, uint8_t idx, double value);
 
void dnp3_command_set_add_g41_v4_u16(dnp3_command_set_t* instance, uint16_t idx, double value);
 
 
typedef enum dnp3_command_mode_t
{
    DNP3_COMMAND_MODE_DIRECT_OPERATE = 0,
    DNP3_COMMAND_MODE_SELECT_BEFORE_OPERATE = 1,
} dnp3_command_mode_t;
 
static const char* dnp3_command_mode_to_string(dnp3_command_mode_t value)
{
    switch (value)
    {
        case DNP3_COMMAND_MODE_DIRECT_OPERATE: return "direct_operate";
        case DNP3_COMMAND_MODE_SELECT_BEFORE_OPERATE: return "select_before_operate";
        default: return "unknown command_mode value";
    }
}
 
typedef enum dnp3_command_error_t
{
    DNP3_COMMAND_ERROR_OK = 0,
    DNP3_COMMAND_ERROR_BAD_STATUS = 1,
    DNP3_COMMAND_ERROR_HEADER_MISMATCH = 2,
    DNP3_COMMAND_ERROR_TOO_MANY_REQUESTS = 3,
    DNP3_COMMAND_ERROR_BAD_RESPONSE = 4,
    DNP3_COMMAND_ERROR_RESPONSE_TIMEOUT = 5,
    DNP3_COMMAND_ERROR_WRITE_ERROR = 6,
    DNP3_COMMAND_ERROR_NO_CONNECTION = 7,
    DNP3_COMMAND_ERROR_SHUTDOWN = 8,
    DNP3_COMMAND_ERROR_ASSOCIATION_REMOVED = 9,
} dnp3_command_error_t;
 
static const char* dnp3_command_error_to_string(dnp3_command_error_t value)
{
    switch (value)
    {
        case DNP3_COMMAND_ERROR_OK: return "ok";
        case DNP3_COMMAND_ERROR_BAD_STATUS: return "bad_status";
        case DNP3_COMMAND_ERROR_HEADER_MISMATCH: return "header_mismatch";
        case DNP3_COMMAND_ERROR_TOO_MANY_REQUESTS: return "too_many_requests";
        case DNP3_COMMAND_ERROR_BAD_RESPONSE: return "bad_response";
        case DNP3_COMMAND_ERROR_RESPONSE_TIMEOUT: return "response_timeout";
        case DNP3_COMMAND_ERROR_WRITE_ERROR: return "write_error";
        case DNP3_COMMAND_ERROR_NO_CONNECTION: return "no_connection";
        case DNP3_COMMAND_ERROR_SHUTDOWN: return "shutdown";
        case DNP3_COMMAND_ERROR_ASSOCIATION_REMOVED: return "association_removed";
        default: return "unknown command_error value";
    }
}
 
 
typedef struct dnp3_command_task_callback_t
{
    
    void (*on_complete)(dnp3_nothing_t, void*);
    
    void (*on_failure)(dnp3_command_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_command_task_callback_t;
 
static dnp3_command_task_callback_t dnp3_command_task_callback_init(
    void (*on_complete)(dnp3_nothing_t, void*),
    void (*on_failure)(dnp3_command_error_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_command_task_callback_t _return_value = {
        on_complete,
        on_failure,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
dnp3_param_error_t dnp3_master_channel_operate(dnp3_master_channel_t* instance, dnp3_association_id_t association, dnp3_command_mode_t mode, dnp3_command_set_t* command, dnp3_command_task_callback_t callback);
 
typedef enum dnp3_time_sync_mode_t
{
    DNP3_TIME_SYNC_MODE_LAN = 0,
    DNP3_TIME_SYNC_MODE_NON_LAN = 1,
} dnp3_time_sync_mode_t;
 
static const char* dnp3_time_sync_mode_to_string(dnp3_time_sync_mode_t value)
{
    switch (value)
    {
        case DNP3_TIME_SYNC_MODE_LAN: return "lan";
        case DNP3_TIME_SYNC_MODE_NON_LAN: return "non_lan";
        default: return "unknown time_sync_mode value";
    }
}
 
typedef enum dnp3_time_sync_error_t
{
    DNP3_TIME_SYNC_ERROR_OK = 0,
    DNP3_TIME_SYNC_ERROR_CLOCK_ROLLBACK = 1,
    DNP3_TIME_SYNC_ERROR_SYSTEM_TIME_NOT_UNIX = 2,
    DNP3_TIME_SYNC_ERROR_BAD_OUTSTATION_TIME_DELAY = 3,
    DNP3_TIME_SYNC_ERROR_OVERFLOW = 4,
    DNP3_TIME_SYNC_ERROR_STILL_NEEDS_TIME = 5,
    DNP3_TIME_SYNC_ERROR_SYSTEM_TIME_NOT_AVAILABLE = 6,
    DNP3_TIME_SYNC_ERROR_IIN_ERROR = 7,
    DNP3_TIME_SYNC_ERROR_TOO_MANY_REQUESTS = 8,
    DNP3_TIME_SYNC_ERROR_BAD_RESPONSE = 9,
    DNP3_TIME_SYNC_ERROR_RESPONSE_TIMEOUT = 10,
    DNP3_TIME_SYNC_ERROR_WRITE_ERROR = 11,
    DNP3_TIME_SYNC_ERROR_NO_CONNECTION = 12,
    DNP3_TIME_SYNC_ERROR_SHUTDOWN = 13,
    DNP3_TIME_SYNC_ERROR_ASSOCIATION_REMOVED = 14,
} dnp3_time_sync_error_t;
 
static const char* dnp3_time_sync_error_to_string(dnp3_time_sync_error_t value)
{
    switch (value)
    {
        case DNP3_TIME_SYNC_ERROR_OK: return "ok";
        case DNP3_TIME_SYNC_ERROR_CLOCK_ROLLBACK: return "clock_rollback";
        case DNP3_TIME_SYNC_ERROR_SYSTEM_TIME_NOT_UNIX: return "system_time_not_unix";
        case DNP3_TIME_SYNC_ERROR_BAD_OUTSTATION_TIME_DELAY: return "bad_outstation_time_delay";
        case DNP3_TIME_SYNC_ERROR_OVERFLOW: return "overflow";
        case DNP3_TIME_SYNC_ERROR_STILL_NEEDS_TIME: return "still_needs_time";
        case DNP3_TIME_SYNC_ERROR_SYSTEM_TIME_NOT_AVAILABLE: return "system_time_not_available";
        case DNP3_TIME_SYNC_ERROR_IIN_ERROR: return "iin_error";
        case DNP3_TIME_SYNC_ERROR_TOO_MANY_REQUESTS: return "too_many_requests";
        case DNP3_TIME_SYNC_ERROR_BAD_RESPONSE: return "bad_response";
        case DNP3_TIME_SYNC_ERROR_RESPONSE_TIMEOUT: return "response_timeout";
        case DNP3_TIME_SYNC_ERROR_WRITE_ERROR: return "write_error";
        case DNP3_TIME_SYNC_ERROR_NO_CONNECTION: return "no_connection";
        case DNP3_TIME_SYNC_ERROR_SHUTDOWN: return "shutdown";
        case DNP3_TIME_SYNC_ERROR_ASSOCIATION_REMOVED: return "association_removed";
        default: return "unknown time_sync_error value";
    }
}
 
 
typedef struct dnp3_time_sync_task_callback_t
{
    
    void (*on_complete)(dnp3_nothing_t, void*);
    
    void (*on_failure)(dnp3_time_sync_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_time_sync_task_callback_t;
 
static dnp3_time_sync_task_callback_t dnp3_time_sync_task_callback_init(
    void (*on_complete)(dnp3_nothing_t, void*),
    void (*on_failure)(dnp3_time_sync_error_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_time_sync_task_callback_t _return_value = {
        on_complete,
        on_failure,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
dnp3_param_error_t dnp3_master_channel_synchronize_time(dnp3_master_channel_t* instance, dnp3_association_id_t association, dnp3_time_sync_mode_t mode, dnp3_time_sync_task_callback_t callback);
 
typedef enum dnp3_restart_error_t
{
    DNP3_RESTART_ERROR_OK = 0,
    DNP3_RESTART_ERROR_TOO_MANY_REQUESTS = 1,
    DNP3_RESTART_ERROR_BAD_RESPONSE = 2,
    DNP3_RESTART_ERROR_RESPONSE_TIMEOUT = 3,
    DNP3_RESTART_ERROR_WRITE_ERROR = 4,
    DNP3_RESTART_ERROR_NO_CONNECTION = 5,
    DNP3_RESTART_ERROR_SHUTDOWN = 6,
    DNP3_RESTART_ERROR_ASSOCIATION_REMOVED = 7,
} dnp3_restart_error_t;
 
static const char* dnp3_restart_error_to_string(dnp3_restart_error_t value)
{
    switch (value)
    {
        case DNP3_RESTART_ERROR_OK: return "ok";
        case DNP3_RESTART_ERROR_TOO_MANY_REQUESTS: return "too_many_requests";
        case DNP3_RESTART_ERROR_BAD_RESPONSE: return "bad_response";
        case DNP3_RESTART_ERROR_RESPONSE_TIMEOUT: return "response_timeout";
        case DNP3_RESTART_ERROR_WRITE_ERROR: return "write_error";
        case DNP3_RESTART_ERROR_NO_CONNECTION: return "no_connection";
        case DNP3_RESTART_ERROR_SHUTDOWN: return "shutdown";
        case DNP3_RESTART_ERROR_ASSOCIATION_REMOVED: return "association_removed";
        default: return "unknown restart_error value";
    }
}
 
 
typedef struct dnp3_restart_task_callback_t
{
    
    void (*on_complete)(uint64_t, void*);
    
    void (*on_failure)(dnp3_restart_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_restart_task_callback_t;
 
static dnp3_restart_task_callback_t dnp3_restart_task_callback_init(
    void (*on_complete)(uint64_t, void*),
    void (*on_failure)(dnp3_restart_error_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_restart_task_callback_t _return_value = {
        on_complete,
        on_failure,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
dnp3_param_error_t dnp3_master_channel_cold_restart(dnp3_master_channel_t* instance, dnp3_association_id_t association, dnp3_restart_task_callback_t callback);
 
dnp3_param_error_t dnp3_master_channel_warm_restart(dnp3_master_channel_t* instance, dnp3_association_id_t association, dnp3_restart_task_callback_t callback);
 
typedef enum dnp3_link_status_error_t
{
    DNP3_LINK_STATUS_ERROR_OK = 0,
    DNP3_LINK_STATUS_ERROR_UNEXPECTED_RESPONSE = 1,
    DNP3_LINK_STATUS_ERROR_TOO_MANY_REQUESTS = 2,
    DNP3_LINK_STATUS_ERROR_BAD_RESPONSE = 3,
    DNP3_LINK_STATUS_ERROR_RESPONSE_TIMEOUT = 4,
    DNP3_LINK_STATUS_ERROR_WRITE_ERROR = 5,
    DNP3_LINK_STATUS_ERROR_NO_CONNECTION = 6,
    DNP3_LINK_STATUS_ERROR_SHUTDOWN = 7,
    DNP3_LINK_STATUS_ERROR_ASSOCIATION_REMOVED = 8,
} dnp3_link_status_error_t;
 
static const char* dnp3_link_status_error_to_string(dnp3_link_status_error_t value)
{
    switch (value)
    {
        case DNP3_LINK_STATUS_ERROR_OK: return "ok";
        case DNP3_LINK_STATUS_ERROR_UNEXPECTED_RESPONSE: return "unexpected_response";
        case DNP3_LINK_STATUS_ERROR_TOO_MANY_REQUESTS: return "too_many_requests";
        case DNP3_LINK_STATUS_ERROR_BAD_RESPONSE: return "bad_response";
        case DNP3_LINK_STATUS_ERROR_RESPONSE_TIMEOUT: return "response_timeout";
        case DNP3_LINK_STATUS_ERROR_WRITE_ERROR: return "write_error";
        case DNP3_LINK_STATUS_ERROR_NO_CONNECTION: return "no_connection";
        case DNP3_LINK_STATUS_ERROR_SHUTDOWN: return "shutdown";
        case DNP3_LINK_STATUS_ERROR_ASSOCIATION_REMOVED: return "association_removed";
        default: return "unknown link_status_error value";
    }
}
 
 
typedef struct dnp3_link_status_callback_t
{
    
    void (*on_complete)(dnp3_nothing_t, void*);
    
    void (*on_failure)(dnp3_link_status_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_link_status_callback_t;
 
static dnp3_link_status_callback_t dnp3_link_status_callback_init(
    void (*on_complete)(dnp3_nothing_t, void*),
    void (*on_failure)(dnp3_link_status_error_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_link_status_callback_t _return_value = {
        on_complete,
        on_failure,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
dnp3_param_error_t dnp3_master_channel_check_link_status(dnp3_master_channel_t* instance, dnp3_association_id_t association, dnp3_link_status_callback_t callback);
 
 
typedef struct dnp3_database_t dnp3_database_t;
 
typedef enum dnp3_event_class_t
{
    DNP3_EVENT_CLASS_NONE = 0,
    DNP3_EVENT_CLASS_CLASS1 = 1,
    DNP3_EVENT_CLASS_CLASS2 = 2,
    DNP3_EVENT_CLASS_CLASS3 = 3,
} dnp3_event_class_t;
 
static const char* dnp3_event_class_to_string(dnp3_event_class_t value)
{
    switch (value)
    {
        case DNP3_EVENT_CLASS_NONE: return "none";
        case DNP3_EVENT_CLASS_CLASS1: return "class1";
        case DNP3_EVENT_CLASS_CLASS2: return "class2";
        case DNP3_EVENT_CLASS_CLASS3: return "class3";
        default: return "unknown event_class value";
    }
}
 
typedef enum dnp3_event_mode_t
{
    DNP3_EVENT_MODE_DETECT = 0,
    DNP3_EVENT_MODE_FORCE = 1,
    DNP3_EVENT_MODE_SUPPRESS = 2,
} dnp3_event_mode_t;
 
static const char* dnp3_event_mode_to_string(dnp3_event_mode_t value)
{
    switch (value)
    {
        case DNP3_EVENT_MODE_DETECT: return "detect";
        case DNP3_EVENT_MODE_FORCE: return "force";
        case DNP3_EVENT_MODE_SUPPRESS: return "suppress";
        default: return "unknown event_mode value";
    }
}
 
typedef struct dnp3_update_options_t dnp3_update_options_t;
 
typedef struct dnp3_update_options_t
{
    bool update_static;
    dnp3_event_mode_t event_mode;
} dnp3_update_options_t;
 
static dnp3_update_options_t dnp3_update_options_detect_event()
{
    dnp3_update_options_t _return_value = {
        true,
        DNP3_EVENT_MODE_DETECT
    };
    return _return_value;
}
 
static dnp3_update_options_t dnp3_update_options_no_event()
{
    dnp3_update_options_t _return_value = {
        true,
        DNP3_EVENT_MODE_SUPPRESS
    };
    return _return_value;
}
 
 
typedef enum dnp3_static_binary_input_variation_t
{
    DNP3_STATIC_BINARY_INPUT_VARIATION_GROUP1_VAR1 = 0,
    DNP3_STATIC_BINARY_INPUT_VARIATION_GROUP1_VAR2 = 1,
} dnp3_static_binary_input_variation_t;
 
static const char* dnp3_static_binary_input_variation_to_string(dnp3_static_binary_input_variation_t value)
{
    switch (value)
    {
        case DNP3_STATIC_BINARY_INPUT_VARIATION_GROUP1_VAR1: return "group1_var1";
        case DNP3_STATIC_BINARY_INPUT_VARIATION_GROUP1_VAR2: return "group1_var2";
        default: return "unknown static_binary_input_variation value";
    }
}
 
typedef enum dnp3_event_binary_input_variation_t
{
    DNP3_EVENT_BINARY_INPUT_VARIATION_GROUP2_VAR1 = 0,
    DNP3_EVENT_BINARY_INPUT_VARIATION_GROUP2_VAR2 = 1,
    DNP3_EVENT_BINARY_INPUT_VARIATION_GROUP2_VAR3 = 2,
} dnp3_event_binary_input_variation_t;
 
static const char* dnp3_event_binary_input_variation_to_string(dnp3_event_binary_input_variation_t value)
{
    switch (value)
    {
        case DNP3_EVENT_BINARY_INPUT_VARIATION_GROUP2_VAR1: return "group2_var1";
        case DNP3_EVENT_BINARY_INPUT_VARIATION_GROUP2_VAR2: return "group2_var2";
        case DNP3_EVENT_BINARY_INPUT_VARIATION_GROUP2_VAR3: return "group2_var3";
        default: return "unknown event_binary_input_variation value";
    }
}
 
typedef struct dnp3_binary_input_config_t dnp3_binary_input_config_t;
 
typedef struct dnp3_binary_input_config_t
{
    dnp3_static_binary_input_variation_t static_variation;
    dnp3_event_binary_input_variation_t event_variation;
} dnp3_binary_input_config_t;
 
static dnp3_binary_input_config_t dnp3_binary_input_config_init()
{
    dnp3_binary_input_config_t _return_value = {
        DNP3_STATIC_BINARY_INPUT_VARIATION_GROUP1_VAR1,
        DNP3_EVENT_BINARY_INPUT_VARIATION_GROUP2_VAR1
    };
    return _return_value;
}
 
 
bool dnp3_database_add_binary_input(dnp3_database_t* instance, uint16_t index, dnp3_event_class_t point_class, dnp3_binary_input_config_t config);
 
bool dnp3_database_remove_binary_input(dnp3_database_t* instance, uint16_t index);
 
bool dnp3_database_update_binary_input(dnp3_database_t* instance, dnp3_binary_input_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_binary_input(dnp3_database_t* instance, uint16_t index, dnp3_binary_input_t* out);
 
typedef enum dnp3_static_double_bit_binary_input_variation_t
{
    DNP3_STATIC_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP3_VAR1 = 0,
    DNP3_STATIC_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP3_VAR2 = 1,
} dnp3_static_double_bit_binary_input_variation_t;
 
static const char* dnp3_static_double_bit_binary_input_variation_to_string(dnp3_static_double_bit_binary_input_variation_t value)
{
    switch (value)
    {
        case DNP3_STATIC_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP3_VAR1: return "group3_var1";
        case DNP3_STATIC_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP3_VAR2: return "group3_var2";
        default: return "unknown static_double_bit_binary_input_variation value";
    }
}
 
typedef enum dnp3_event_double_bit_binary_input_variation_t
{
    DNP3_EVENT_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP4_VAR1 = 0,
    DNP3_EVENT_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP4_VAR2 = 1,
    DNP3_EVENT_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP4_VAR3 = 2,
} dnp3_event_double_bit_binary_input_variation_t;
 
static const char* dnp3_event_double_bit_binary_input_variation_to_string(dnp3_event_double_bit_binary_input_variation_t value)
{
    switch (value)
    {
        case DNP3_EVENT_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP4_VAR1: return "group4_var1";
        case DNP3_EVENT_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP4_VAR2: return "group4_var2";
        case DNP3_EVENT_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP4_VAR3: return "group4_var3";
        default: return "unknown event_double_bit_binary_input_variation value";
    }
}
 
typedef struct dnp3_double_bit_binary_input_config_t dnp3_double_bit_binary_input_config_t;
 
typedef struct dnp3_double_bit_binary_input_config_t
{
    dnp3_static_double_bit_binary_input_variation_t static_variation;
    dnp3_event_double_bit_binary_input_variation_t event_variation;
} dnp3_double_bit_binary_input_config_t;
 
static dnp3_double_bit_binary_input_config_t dnp3_double_bit_binary_input_config_init()
{
    dnp3_double_bit_binary_input_config_t _return_value = {
        DNP3_STATIC_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP3_VAR1,
        DNP3_EVENT_DOUBLE_BIT_BINARY_INPUT_VARIATION_GROUP4_VAR1
    };
    return _return_value;
}
 
 
bool dnp3_database_add_double_bit_binary_input(dnp3_database_t* instance, uint16_t index, dnp3_event_class_t point_class, dnp3_double_bit_binary_input_config_t config);
 
bool dnp3_database_remove_double_bit_binary_input(dnp3_database_t* instance, uint16_t index);
 
bool dnp3_database_update_double_bit_binary_input(dnp3_database_t* instance, dnp3_double_bit_binary_input_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_double_bit_binary_input(dnp3_database_t* instance, uint16_t index, dnp3_double_bit_binary_input_t* out);
 
typedef enum dnp3_static_binary_output_status_variation_t
{
    DNP3_STATIC_BINARY_OUTPUT_STATUS_VARIATION_GROUP10_VAR1 = 0,
    DNP3_STATIC_BINARY_OUTPUT_STATUS_VARIATION_GROUP10_VAR2 = 1,
} dnp3_static_binary_output_status_variation_t;
 
static const char* dnp3_static_binary_output_status_variation_to_string(dnp3_static_binary_output_status_variation_t value)
{
    switch (value)
    {
        case DNP3_STATIC_BINARY_OUTPUT_STATUS_VARIATION_GROUP10_VAR1: return "group10_var1";
        case DNP3_STATIC_BINARY_OUTPUT_STATUS_VARIATION_GROUP10_VAR2: return "group10_var2";
        default: return "unknown static_binary_output_status_variation value";
    }
}
 
typedef enum dnp3_event_binary_output_status_variation_t
{
    DNP3_EVENT_BINARY_OUTPUT_STATUS_VARIATION_GROUP11_VAR1 = 0,
    DNP3_EVENT_BINARY_OUTPUT_STATUS_VARIATION_GROUP11_VAR2 = 1,
} dnp3_event_binary_output_status_variation_t;
 
static const char* dnp3_event_binary_output_status_variation_to_string(dnp3_event_binary_output_status_variation_t value)
{
    switch (value)
    {
        case DNP3_EVENT_BINARY_OUTPUT_STATUS_VARIATION_GROUP11_VAR1: return "group11_var1";
        case DNP3_EVENT_BINARY_OUTPUT_STATUS_VARIATION_GROUP11_VAR2: return "group11_var2";
        default: return "unknown event_binary_output_status_variation value";
    }
}
 
typedef struct dnp3_binary_output_status_config_t dnp3_binary_output_status_config_t;
 
typedef struct dnp3_binary_output_status_config_t
{
    dnp3_static_binary_output_status_variation_t static_variation;
    dnp3_event_binary_output_status_variation_t event_variation;
} dnp3_binary_output_status_config_t;
 
static dnp3_binary_output_status_config_t dnp3_binary_output_status_config_init()
{
    dnp3_binary_output_status_config_t _return_value = {
        DNP3_STATIC_BINARY_OUTPUT_STATUS_VARIATION_GROUP10_VAR1,
        DNP3_EVENT_BINARY_OUTPUT_STATUS_VARIATION_GROUP11_VAR2
    };
    return _return_value;
}
 
 
bool dnp3_database_add_binary_output_status(dnp3_database_t* instance, uint16_t index, dnp3_event_class_t point_class, dnp3_binary_output_status_config_t config);
 
bool dnp3_database_remove_binary_output_status(dnp3_database_t* instance, uint16_t index);
 
bool dnp3_database_update_binary_output_status(dnp3_database_t* instance, dnp3_binary_output_status_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_binary_output_status(dnp3_database_t* instance, uint16_t index, dnp3_binary_output_status_t* out);
 
typedef enum dnp3_static_counter_variation_t
{
    DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR1 = 0,
    DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR2 = 1,
    DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR5 = 2,
    DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR6 = 3,
} dnp3_static_counter_variation_t;
 
static const char* dnp3_static_counter_variation_to_string(dnp3_static_counter_variation_t value)
{
    switch (value)
    {
        case DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR1: return "group20_var1";
        case DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR2: return "group20_var2";
        case DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR5: return "group20_var5";
        case DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR6: return "group20_var6";
        default: return "unknown static_counter_variation value";
    }
}
 
typedef enum dnp3_event_counter_variation_t
{
    DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR1 = 0,
    DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR2 = 1,
    DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR5 = 2,
    DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR6 = 3,
} dnp3_event_counter_variation_t;
 
static const char* dnp3_event_counter_variation_to_string(dnp3_event_counter_variation_t value)
{
    switch (value)
    {
        case DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR1: return "group22_var1";
        case DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR2: return "group22_var2";
        case DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR5: return "group22_var5";
        case DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR6: return "group22_var6";
        default: return "unknown event_counter_variation value";
    }
}
 
typedef struct dnp3_counter_config_t dnp3_counter_config_t;
 
typedef struct dnp3_counter_config_t
{
    dnp3_static_counter_variation_t static_variation;
    dnp3_event_counter_variation_t event_variation;
    uint32_t deadband;
} dnp3_counter_config_t;
 
static dnp3_counter_config_t dnp3_counter_config_init()
{
    dnp3_counter_config_t _return_value = {
        DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR1,
        DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR1,
        0
    };
    return _return_value;
}
 
 
bool dnp3_database_add_counter(dnp3_database_t* instance, uint16_t index, dnp3_event_class_t point_class, dnp3_counter_config_t config);
 
bool dnp3_database_remove_counter(dnp3_database_t* instance, uint16_t index);
 
bool dnp3_database_update_counter(dnp3_database_t* instance, dnp3_counter_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_counter(dnp3_database_t* instance, uint16_t index, dnp3_counter_t* out);
 
typedef enum dnp3_static_frozen_counter_variation_t
{
    DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR1 = 0,
    DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR2 = 1,
    DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR5 = 2,
    DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR6 = 3,
    DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR9 = 4,
    DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR10 = 5,
} dnp3_static_frozen_counter_variation_t;
 
static const char* dnp3_static_frozen_counter_variation_to_string(dnp3_static_frozen_counter_variation_t value)
{
    switch (value)
    {
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR1: return "group21_var1";
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR2: return "group21_var2";
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR5: return "group21_var5";
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR6: return "group21_var6";
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR9: return "group21_var9";
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR10: return "group21_var10";
        default: return "unknown static_frozen_counter_variation value";
    }
}
 
typedef enum dnp3_event_frozen_counter_variation_t
{
    DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR1 = 0,
    DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR2 = 1,
    DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR5 = 2,
    DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR6 = 3,
} dnp3_event_frozen_counter_variation_t;
 
static const char* dnp3_event_frozen_counter_variation_to_string(dnp3_event_frozen_counter_variation_t value)
{
    switch (value)
    {
        case DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR1: return "group23_var1";
        case DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR2: return "group23_var2";
        case DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR5: return "group23_var5";
        case DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR6: return "group23_var6";
        default: return "unknown event_frozen_counter_variation value";
    }
}
 
typedef struct dnp3_frozen_counter_config_t dnp3_frozen_counter_config_t;
 
typedef struct dnp3_frozen_counter_config_t
{
    dnp3_static_frozen_counter_variation_t static_variation;
    dnp3_event_frozen_counter_variation_t event_variation;
    uint32_t deadband;
} dnp3_frozen_counter_config_t;
 
static dnp3_frozen_counter_config_t dnp3_frozen_counter_config_init()
{
    dnp3_frozen_counter_config_t _return_value = {
        DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR1,
        DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR1,
        0
    };
    return _return_value;
}
 
 
bool dnp3_database_add_frozen_counter(dnp3_database_t* instance, uint16_t index, dnp3_event_class_t point_class, dnp3_frozen_counter_config_t config);
 
bool dnp3_database_remove_frozen_counter(dnp3_database_t* instance, uint16_t index);
 
bool dnp3_database_update_frozen_counter(dnp3_database_t* instance, dnp3_frozen_counter_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_frozen_counter(dnp3_database_t* instance, uint16_t index, dnp3_frozen_counter_t* out);
 
typedef enum dnp3_static_analog_input_variation_t
{
    DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR1 = 0,
    DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR2 = 1,
    DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR3 = 2,
    DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR4 = 3,
    DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR5 = 4,
    DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR6 = 5,
} dnp3_static_analog_input_variation_t;
 
static const char* dnp3_static_analog_input_variation_to_string(dnp3_static_analog_input_variation_t value)
{
    switch (value)
    {
        case DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR1: return "group30_var1";
        case DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR2: return "group30_var2";
        case DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR3: return "group30_var3";
        case DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR4: return "group30_var4";
        case DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR5: return "group30_var5";
        case DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR6: return "group30_var6";
        default: return "unknown static_analog_input_variation value";
    }
}
 
typedef enum dnp3_event_analog_input_variation_t
{
    DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR1 = 0,
    DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR2 = 1,
    DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR3 = 2,
    DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR4 = 3,
    DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR5 = 4,
    DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR6 = 5,
    DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR7 = 6,
    DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR8 = 7,
} dnp3_event_analog_input_variation_t;
 
static const char* dnp3_event_analog_input_variation_to_string(dnp3_event_analog_input_variation_t value)
{
    switch (value)
    {
        case DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR1: return "group32_var1";
        case DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR2: return "group32_var2";
        case DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR3: return "group32_var3";
        case DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR4: return "group32_var4";
        case DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR5: return "group32_var5";
        case DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR6: return "group32_var6";
        case DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR7: return "group32_var7";
        case DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR8: return "group32_var8";
        default: return "unknown event_analog_input_variation value";
    }
}
 
typedef struct dnp3_analog_input_config_t dnp3_analog_input_config_t;
 
typedef struct dnp3_analog_input_config_t
{
    dnp3_static_analog_input_variation_t static_variation;
    dnp3_event_analog_input_variation_t event_variation;
    double deadband;
} dnp3_analog_input_config_t;
 
static dnp3_analog_input_config_t dnp3_analog_input_config_init()
{
    dnp3_analog_input_config_t _return_value = {
        DNP3_STATIC_ANALOG_INPUT_VARIATION_GROUP30_VAR1,
        DNP3_EVENT_ANALOG_INPUT_VARIATION_GROUP32_VAR1,
        0
    };
    return _return_value;
}
 
 
bool dnp3_database_add_analog_input(dnp3_database_t* instance, uint16_t index, dnp3_event_class_t point_class, dnp3_analog_input_config_t config);
 
bool dnp3_database_remove_analog_input(dnp3_database_t* instance, uint16_t index);
 
bool dnp3_database_update_analog_input(dnp3_database_t* instance, dnp3_analog_input_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_analog_input(dnp3_database_t* instance, uint16_t index, dnp3_analog_input_t* out);
 
typedef enum dnp3_static_analog_output_status_variation_t
{
    DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR1 = 0,
    DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR2 = 1,
    DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR3 = 2,
    DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR4 = 3,
} dnp3_static_analog_output_status_variation_t;
 
static const char* dnp3_static_analog_output_status_variation_to_string(dnp3_static_analog_output_status_variation_t value)
{
    switch (value)
    {
        case DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR1: return "group40_var1";
        case DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR2: return "group40_var2";
        case DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR3: return "group40_var3";
        case DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR4: return "group40_var4";
        default: return "unknown static_analog_output_status_variation value";
    }
}
 
typedef enum dnp3_event_analog_output_status_variation_t
{
    DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR1 = 0,
    DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR2 = 1,
    DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR3 = 2,
    DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR4 = 3,
    DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR5 = 4,
    DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR6 = 5,
    DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR7 = 6,
    DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR8 = 7,
} dnp3_event_analog_output_status_variation_t;
 
static const char* dnp3_event_analog_output_status_variation_to_string(dnp3_event_analog_output_status_variation_t value)
{
    switch (value)
    {
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR1: return "group42_var1";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR2: return "group42_var2";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR3: return "group42_var3";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR4: return "group42_var4";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR5: return "group42_var5";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR6: return "group42_var6";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR7: return "group42_var7";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR8: return "group42_var8";
        default: return "unknown event_analog_output_status_variation value";
    }
}
 
typedef struct dnp3_analog_output_status_config_t dnp3_analog_output_status_config_t;
 
typedef struct dnp3_analog_output_status_config_t
{
    dnp3_static_analog_output_status_variation_t static_variation;
    dnp3_event_analog_output_status_variation_t event_variation;
    double deadband;
} dnp3_analog_output_status_config_t;
 
static dnp3_analog_output_status_config_t dnp3_analog_output_status_config_init()
{
    dnp3_analog_output_status_config_t _return_value = {
        DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR1,
        DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR1,
        0
    };
    return _return_value;
}
 
 
bool dnp3_database_add_analog_output_status(dnp3_database_t* instance, uint16_t index, dnp3_event_class_t point_class, dnp3_analog_output_status_config_t config);
 
bool dnp3_database_remove_analog_output_status(dnp3_database_t* instance, uint16_t index);
 
bool dnp3_database_update_analog_output_status(dnp3_database_t* instance, dnp3_analog_output_status_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_analog_output_status(dnp3_database_t* instance, uint16_t index, dnp3_analog_output_status_t* out);
 
typedef struct dnp3_octet_string_value_t dnp3_octet_string_value_t;
 
dnp3_octet_string_value_t* dnp3_octet_string_value_create();
 
void dnp3_octet_string_value_destroy(dnp3_octet_string_value_t* instance);
 
void dnp3_octet_string_value_add(dnp3_octet_string_value_t* instance, uint8_t value);
 
 
bool dnp3_database_add_octet_string(dnp3_database_t* instance, uint16_t index, dnp3_event_class_t point_class);
 
bool dnp3_database_remove_octet_string(dnp3_database_t* instance, uint16_t index);
 
bool dnp3_database_update_octet_string(dnp3_database_t* instance, uint16_t index, dnp3_octet_string_value_t* value, dnp3_update_options_t options);
 
 
typedef struct dnp3_database_transaction_t
{
    
    void (*execute)(dnp3_database_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_database_transaction_t;
 
static dnp3_database_transaction_t dnp3_database_transaction_init(
    void (*execute)(dnp3_database_t*, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_database_transaction_t _return_value = {
        execute,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
typedef struct dnp3_database_handle_t dnp3_database_handle_t;
 
void dnp3_database_handle_transaction(dnp3_database_handle_t* instance, dnp3_database_transaction_t callback);
 
 
typedef struct dnp3_event_buffer_config_t dnp3_event_buffer_config_t;
 
typedef struct dnp3_event_buffer_config_t
{
    uint16_t max_binary;
    uint16_t max_double_bit_binary;
    uint16_t max_binary_output_status;
    uint16_t max_counter;
    uint16_t max_frozen_counter;
    uint16_t max_analog;
    uint16_t max_analog_output_status;
    uint16_t max_octet_string;
} dnp3_event_buffer_config_t;
 
static dnp3_event_buffer_config_t dnp3_event_buffer_config_init(uint16_t max_binary, uint16_t max_double_bit_binary, uint16_t max_binary_output_status, uint16_t max_counter, uint16_t max_frozen_counter, uint16_t max_analog, uint16_t max_analog_output_status, uint16_t max_octet_string)
{
    dnp3_event_buffer_config_t _return_value = {
        max_binary,
        max_double_bit_binary,
        max_binary_output_status,
        max_counter,
        max_frozen_counter,
        max_analog,
        max_analog_output_status,
        max_octet_string
    };
    return _return_value;
}
 
static dnp3_event_buffer_config_t dnp3_event_buffer_config_no_events()
{
    dnp3_event_buffer_config_t _return_value = {
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0
    };
    return _return_value;
}
 
 
typedef struct dnp3_class_zero_config_t dnp3_class_zero_config_t;
 
typedef struct dnp3_class_zero_config_t
{
    bool binary;
    bool double_bit_binary;
    bool binary_output_status;
    bool counter;
    bool frozen_counter;
    bool analog;
    bool analog_output_status;
    bool octet_string;
} dnp3_class_zero_config_t;
 
static dnp3_class_zero_config_t dnp3_class_zero_config_init()
{
    dnp3_class_zero_config_t _return_value = {
        true,
        true,
        true,
        true,
        true,
        true,
        true,
        false
    };
    return _return_value;
}
 
 
typedef struct dnp3_outstation_features_t dnp3_outstation_features_t;
 
typedef struct dnp3_outstation_features_t
{
    bool self_address;
    bool broadcast;
    bool unsolicited;
} dnp3_outstation_features_t;
 
static dnp3_outstation_features_t dnp3_outstation_features_init()
{
    dnp3_outstation_features_t _return_value = {
        false,
        true,
        true
    };
    return _return_value;
}
 
 
typedef struct dnp3_outstation_config_t dnp3_outstation_config_t;
 
typedef struct dnp3_outstation_config_t
{
    uint16_t outstation_address;
    uint16_t master_address;
    dnp3_event_buffer_config_t event_buffer_config;
    uint16_t solicited_buffer_size;
    uint16_t unsolicited_buffer_size;
    uint16_t rx_buffer_size;
    dnp3_decode_level_t decode_level;
    uint64_t confirm_timeout;
    uint64_t select_timeout;
    dnp3_outstation_features_t features;
    uint32_t max_unsolicited_retries;
    uint64_t unsolicited_retry_delay;
    uint64_t keep_alive_timeout;
    uint16_t max_read_request_headers;
    uint16_t max_controls_per_request;
    dnp3_class_zero_config_t class_zero;
} dnp3_outstation_config_t;
 
static dnp3_outstation_config_t dnp3_outstation_config_init(uint16_t outstation_address, uint16_t master_address, dnp3_event_buffer_config_t event_buffer_config)
{
    dnp3_outstation_config_t _return_value = {
        outstation_address,
        master_address,
        event_buffer_config,
        2048,
        2048,
        2048,
        dnp3_decode_level_init(),
        5000,
        5000,
        dnp3_outstation_features_init(),
        4294967295,
        5000,
        60000,
        64,
        65535,
        dnp3_class_zero_config_init()
    };
    return _return_value;
}
 
 
typedef enum dnp3_restart_delay_type_t
{
    DNP3_RESTART_DELAY_TYPE_NOT_SUPPORTED = 0,
    DNP3_RESTART_DELAY_TYPE_SECONDS = 1,
    DNP3_RESTART_DELAY_TYPE_MILLI_SECONDS = 2,
} dnp3_restart_delay_type_t;
 
static const char* dnp3_restart_delay_type_to_string(dnp3_restart_delay_type_t value)
{
    switch (value)
    {
        case DNP3_RESTART_DELAY_TYPE_NOT_SUPPORTED: return "not_supported";
        case DNP3_RESTART_DELAY_TYPE_SECONDS: return "seconds";
        case DNP3_RESTART_DELAY_TYPE_MILLI_SECONDS: return "milli_seconds";
        default: return "unknown restart_delay_type value";
    }
}
 
typedef struct dnp3_restart_delay_t dnp3_restart_delay_t;
 
typedef struct dnp3_restart_delay_t
{
    dnp3_restart_delay_type_t restart_type;
    uint16_t value;
} dnp3_restart_delay_t;
 
static dnp3_restart_delay_t dnp3_restart_delay_not_supported()
{
    dnp3_restart_delay_t _return_value = {
        DNP3_RESTART_DELAY_TYPE_NOT_SUPPORTED,
        0
    };
    return _return_value;
}
 
static dnp3_restart_delay_t dnp3_restart_delay_seconds(uint16_t value)
{
    dnp3_restart_delay_t _return_value = {
        DNP3_RESTART_DELAY_TYPE_SECONDS,
        value
    };
    return _return_value;
}
 
static dnp3_restart_delay_t dnp3_restart_delay_milliseconds(uint16_t value)
{
    dnp3_restart_delay_t _return_value = {
        DNP3_RESTART_DELAY_TYPE_MILLI_SECONDS,
        value
    };
    return _return_value;
}
 
 
typedef enum dnp3_write_time_result_t
{
    DNP3_WRITE_TIME_RESULT_OK = 0,
    DNP3_WRITE_TIME_RESULT_PARAMETER_ERROR = 1,
    DNP3_WRITE_TIME_RESULT_NOT_SUPPORTED = 2,
} dnp3_write_time_result_t;
 
static const char* dnp3_write_time_result_to_string(dnp3_write_time_result_t value)
{
    switch (value)
    {
        case DNP3_WRITE_TIME_RESULT_OK: return "ok";
        case DNP3_WRITE_TIME_RESULT_PARAMETER_ERROR: return "parameter_error";
        case DNP3_WRITE_TIME_RESULT_NOT_SUPPORTED: return "not_supported";
        default: return "unknown write_time_result value";
    }
}
 
typedef enum dnp3_freeze_type_t
{
    DNP3_FREEZE_TYPE_IMMEDIATE_FREEZE = 0,
    DNP3_FREEZE_TYPE_FREEZE_AND_CLEAR = 1,
} dnp3_freeze_type_t;
 
static const char* dnp3_freeze_type_to_string(dnp3_freeze_type_t value)
{
    switch (value)
    {
        case DNP3_FREEZE_TYPE_IMMEDIATE_FREEZE: return "immediate_freeze";
        case DNP3_FREEZE_TYPE_FREEZE_AND_CLEAR: return "freeze_and_clear";
        default: return "unknown freeze_type value";
    }
}
 
typedef enum dnp3_freeze_result_t
{
    DNP3_FREEZE_RESULT_OK = 0,
    DNP3_FREEZE_RESULT_PARAMETER_ERROR = 1,
    DNP3_FREEZE_RESULT_NOT_SUPPORTED = 2,
} dnp3_freeze_result_t;
 
static const char* dnp3_freeze_result_to_string(dnp3_freeze_result_t value)
{
    switch (value)
    {
        case DNP3_FREEZE_RESULT_OK: return "ok";
        case DNP3_FREEZE_RESULT_PARAMETER_ERROR: return "parameter_error";
        case DNP3_FREEZE_RESULT_NOT_SUPPORTED: return "not_supported";
        default: return "unknown freeze_result value";
    }
}
 
typedef struct dnp3_application_iin_t dnp3_application_iin_t;
 
typedef struct dnp3_application_iin_t
{
    bool need_time;
    bool local_control;
    bool device_trouble;
    bool config_corrupt;
} dnp3_application_iin_t;
 
static dnp3_application_iin_t dnp3_application_iin_init()
{
    dnp3_application_iin_t _return_value = {
        false,
        false,
        false,
        false
    };
    return _return_value;
}
 
 
typedef struct dnp3_outstation_application_t
{
    
    uint16_t (*get_processing_delay_ms)(void*);
    
    dnp3_write_time_result_t (*write_absolute_time)(uint64_t, void*);
    
    dnp3_application_iin_t (*get_application_iin)(void*);
    
    dnp3_restart_delay_t (*cold_restart)(void*);
    
    dnp3_restart_delay_t (*warm_restart)(void*);
    
    dnp3_freeze_result_t (*freeze_counters_all)(dnp3_freeze_type_t, dnp3_database_handle_t*, void*);
    
    dnp3_freeze_result_t (*freeze_counters_range)(uint16_t, uint16_t, dnp3_freeze_type_t, dnp3_database_handle_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_outstation_application_t;
 
static dnp3_outstation_application_t dnp3_outstation_application_init(
    uint16_t (*get_processing_delay_ms)(void*),
    dnp3_write_time_result_t (*write_absolute_time)(uint64_t, void*),
    dnp3_application_iin_t (*get_application_iin)(void*),
    dnp3_restart_delay_t (*cold_restart)(void*),
    dnp3_restart_delay_t (*warm_restart)(void*),
    dnp3_freeze_result_t (*freeze_counters_all)(dnp3_freeze_type_t, dnp3_database_handle_t*, void*),
    dnp3_freeze_result_t (*freeze_counters_range)(uint16_t, uint16_t, dnp3_freeze_type_t, dnp3_database_handle_t*, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_outstation_application_t _return_value = {
        get_processing_delay_ms,
        write_absolute_time,
        get_application_iin,
        cold_restart,
        warm_restart,
        freeze_counters_all,
        freeze_counters_range,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
typedef struct dnp3_request_header_t dnp3_request_header_t;
 
typedef struct dnp3_request_header_t
{
    dnp3_control_field_t control_field;
    dnp3_function_code_t function;
} dnp3_request_header_t;
 
 
typedef enum dnp3_broadcast_action_t
{
    DNP3_BROADCAST_ACTION_PROCESSED = 0,
    DNP3_BROADCAST_ACTION_IGNORED_BY_CONFIGURATION = 1,
    DNP3_BROADCAST_ACTION_BAD_OBJECT_HEADERS = 2,
    DNP3_BROADCAST_ACTION_UNSUPPORTED_FUNCTION = 3,
} dnp3_broadcast_action_t;
 
static const char* dnp3_broadcast_action_to_string(dnp3_broadcast_action_t value)
{
    switch (value)
    {
        case DNP3_BROADCAST_ACTION_PROCESSED: return "processed";
        case DNP3_BROADCAST_ACTION_IGNORED_BY_CONFIGURATION: return "ignored_by_configuration";
        case DNP3_BROADCAST_ACTION_BAD_OBJECT_HEADERS: return "bad_object_headers";
        case DNP3_BROADCAST_ACTION_UNSUPPORTED_FUNCTION: return "unsupported_function";
        default: return "unknown broadcast_action value";
    }
}
 
typedef struct dnp3_outstation_information_t
{
    
    void (*process_request_from_idle)(dnp3_request_header_t, void*);
    
    void (*broadcast_received)(dnp3_function_code_t, dnp3_broadcast_action_t, void*);
    
    void (*enter_solicited_confirm_wait)(uint8_t, void*);
    
    void (*solicited_confirm_timeout)(uint8_t, void*);
    
    void (*solicited_confirm_received)(uint8_t, void*);
    
    void (*solicited_confirm_wait_new_request)(void*);
    
    void (*wrong_solicited_confirm_seq)(uint8_t, uint8_t, void*);
    
    void (*unexpected_confirm)(bool, uint8_t, void*);
    
    void (*enter_unsolicited_confirm_wait)(uint8_t, void*);
    
    void (*unsolicited_confirm_timeout)(uint8_t, bool, void*);
    
    void (*unsolicited_confirmed)(uint8_t, void*);
    
    void (*clear_restart_iin)(void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_outstation_information_t;
 
static dnp3_outstation_information_t dnp3_outstation_information_init(
    void (*process_request_from_idle)(dnp3_request_header_t, void*),
    void (*broadcast_received)(dnp3_function_code_t, dnp3_broadcast_action_t, void*),
    void (*enter_solicited_confirm_wait)(uint8_t, void*),
    void (*solicited_confirm_timeout)(uint8_t, void*),
    void (*solicited_confirm_received)(uint8_t, void*),
    void (*solicited_confirm_wait_new_request)(void*),
    void (*wrong_solicited_confirm_seq)(uint8_t, uint8_t, void*),
    void (*unexpected_confirm)(bool, uint8_t, void*),
    void (*enter_unsolicited_confirm_wait)(uint8_t, void*),
    void (*unsolicited_confirm_timeout)(uint8_t, bool, void*),
    void (*unsolicited_confirmed)(uint8_t, void*),
    void (*clear_restart_iin)(void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_outstation_information_t _return_value = {
        process_request_from_idle,
        broadcast_received,
        enter_solicited_confirm_wait,
        solicited_confirm_timeout,
        solicited_confirm_received,
        solicited_confirm_wait_new_request,
        wrong_solicited_confirm_seq,
        unexpected_confirm,
        enter_unsolicited_confirm_wait,
        unsolicited_confirm_timeout,
        unsolicited_confirmed,
        clear_restart_iin,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
typedef enum dnp3_command_status_t
{
    DNP3_COMMAND_STATUS_SUCCESS = 0,
    DNP3_COMMAND_STATUS_TIMEOUT = 1,
    DNP3_COMMAND_STATUS_NO_SELECT = 2,
    DNP3_COMMAND_STATUS_FORMAT_ERROR = 3,
    DNP3_COMMAND_STATUS_NOT_SUPPORTED = 4,
    DNP3_COMMAND_STATUS_ALREADY_ACTIVE = 5,
    DNP3_COMMAND_STATUS_HARDWARE_ERROR = 6,
    DNP3_COMMAND_STATUS_LOCAL = 7,
    DNP3_COMMAND_STATUS_TOO_MANY_OPS = 8,
    DNP3_COMMAND_STATUS_NOT_AUTHORIZED = 9,
    DNP3_COMMAND_STATUS_AUTOMATION_INHIBIT = 10,
    DNP3_COMMAND_STATUS_PROCESSING_LIMITED = 11,
    DNP3_COMMAND_STATUS_OUT_OF_RANGE = 12,
    DNP3_COMMAND_STATUS_DOWNSTREAM_LOCAL = 13,
    DNP3_COMMAND_STATUS_ALREADY_COMPLETE = 14,
    DNP3_COMMAND_STATUS_BLOCKED = 15,
    DNP3_COMMAND_STATUS_CANCELED = 16,
    DNP3_COMMAND_STATUS_BLOCKED_OTHER_MASTER = 17,
    DNP3_COMMAND_STATUS_DOWNSTREAM_FAIL = 18,
    DNP3_COMMAND_STATUS_NON_PARTICIPATING = 19,
    DNP3_COMMAND_STATUS_UNKNOWN = 20,
} dnp3_command_status_t;
 
static const char* dnp3_command_status_to_string(dnp3_command_status_t value)
{
    switch (value)
    {
        case DNP3_COMMAND_STATUS_SUCCESS: return "success";
        case DNP3_COMMAND_STATUS_TIMEOUT: return "timeout";
        case DNP3_COMMAND_STATUS_NO_SELECT: return "no_select";
        case DNP3_COMMAND_STATUS_FORMAT_ERROR: return "format_error";
        case DNP3_COMMAND_STATUS_NOT_SUPPORTED: return "not_supported";
        case DNP3_COMMAND_STATUS_ALREADY_ACTIVE: return "already_active";
        case DNP3_COMMAND_STATUS_HARDWARE_ERROR: return "hardware_error";
        case DNP3_COMMAND_STATUS_LOCAL: return "local";
        case DNP3_COMMAND_STATUS_TOO_MANY_OPS: return "too_many_ops";
        case DNP3_COMMAND_STATUS_NOT_AUTHORIZED: return "not_authorized";
        case DNP3_COMMAND_STATUS_AUTOMATION_INHIBIT: return "automation_inhibit";
        case DNP3_COMMAND_STATUS_PROCESSING_LIMITED: return "processing_limited";
        case DNP3_COMMAND_STATUS_OUT_OF_RANGE: return "out_of_range";
        case DNP3_COMMAND_STATUS_DOWNSTREAM_LOCAL: return "downstream_local";
        case DNP3_COMMAND_STATUS_ALREADY_COMPLETE: return "already_complete";
        case DNP3_COMMAND_STATUS_BLOCKED: return "blocked";
        case DNP3_COMMAND_STATUS_CANCELED: return "canceled";
        case DNP3_COMMAND_STATUS_BLOCKED_OTHER_MASTER: return "blocked_other_master";
        case DNP3_COMMAND_STATUS_DOWNSTREAM_FAIL: return "downstream_fail";
        case DNP3_COMMAND_STATUS_NON_PARTICIPATING: return "non_participating";
        case DNP3_COMMAND_STATUS_UNKNOWN: return "unknown";
        default: return "unknown command_status value";
    }
}
 
typedef enum dnp3_operate_type_t
{
    DNP3_OPERATE_TYPE_SELECT_BEFORE_OPERATE = 0,
    DNP3_OPERATE_TYPE_DIRECT_OPERATE = 1,
    DNP3_OPERATE_TYPE_DIRECT_OPERATE_NO_ACK = 2,
} dnp3_operate_type_t;
 
static const char* dnp3_operate_type_to_string(dnp3_operate_type_t value)
{
    switch (value)
    {
        case DNP3_OPERATE_TYPE_SELECT_BEFORE_OPERATE: return "select_before_operate";
        case DNP3_OPERATE_TYPE_DIRECT_OPERATE: return "direct_operate";
        case DNP3_OPERATE_TYPE_DIRECT_OPERATE_NO_ACK: return "direct_operate_no_ack";
        default: return "unknown operate_type value";
    }
}
 
typedef struct dnp3_control_handler_t
{
    
    void (*begin_fragment)(void*);
    
    void (*end_fragment)(dnp3_database_handle_t*, void*);
    
    dnp3_command_status_t (*select_g12v1)(dnp3_group12_var1_t, uint16_t, dnp3_database_handle_t*, void*);
    
    dnp3_command_status_t (*operate_g12v1)(dnp3_group12_var1_t, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*);
    
    dnp3_command_status_t (*select_g41v1)(int32_t, uint16_t, dnp3_database_handle_t*, void*);
    
    dnp3_command_status_t (*operate_g41v1)(int32_t, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*);
    
    dnp3_command_status_t (*select_g41v2)(int16_t, uint16_t, dnp3_database_handle_t*, void*);
    
    dnp3_command_status_t (*operate_g41v2)(int16_t, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*);
    
    dnp3_command_status_t (*select_g41v3)(float, uint16_t, dnp3_database_handle_t*, void*);
    
    dnp3_command_status_t (*operate_g41v3)(float, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*);
    
    dnp3_command_status_t (*select_g41v4)(double, uint16_t, dnp3_database_handle_t*, void*);
    
    dnp3_command_status_t (*operate_g41v4)(double, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_control_handler_t;
 
static dnp3_control_handler_t dnp3_control_handler_init(
    void (*begin_fragment)(void*),
    void (*end_fragment)(dnp3_database_handle_t*, void*),
    dnp3_command_status_t (*select_g12v1)(dnp3_group12_var1_t, uint16_t, dnp3_database_handle_t*, void*),
    dnp3_command_status_t (*operate_g12v1)(dnp3_group12_var1_t, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*),
    dnp3_command_status_t (*select_g41v1)(int32_t, uint16_t, dnp3_database_handle_t*, void*),
    dnp3_command_status_t (*operate_g41v1)(int32_t, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*),
    dnp3_command_status_t (*select_g41v2)(int16_t, uint16_t, dnp3_database_handle_t*, void*),
    dnp3_command_status_t (*operate_g41v2)(int16_t, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*),
    dnp3_command_status_t (*select_g41v3)(float, uint16_t, dnp3_database_handle_t*, void*),
    dnp3_command_status_t (*operate_g41v3)(float, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*),
    dnp3_command_status_t (*select_g41v4)(double, uint16_t, dnp3_database_handle_t*, void*),
    dnp3_command_status_t (*operate_g41v4)(double, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_control_handler_t _return_value = {
        begin_fragment,
        end_fragment,
        select_g12v1,
        operate_g12v1,
        select_g41v1,
        operate_g41v1,
        select_g41v2,
        operate_g41v2,
        select_g41v3,
        operate_g41v3,
        select_g41v4,
        operate_g41v4,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
typedef enum dnp3_connection_state_t
{
    DNP3_CONNECTION_STATE_CONNECTED = 0,
    DNP3_CONNECTION_STATE_DISCONNECTED = 1,
} dnp3_connection_state_t;
 
static const char* dnp3_connection_state_to_string(dnp3_connection_state_t value)
{
    switch (value)
    {
        case DNP3_CONNECTION_STATE_CONNECTED: return "connected";
        case DNP3_CONNECTION_STATE_DISCONNECTED: return "disconnected";
        default: return "unknown connection_state value";
    }
}
 
typedef struct dnp3_connection_state_listener_t
{
    
    void (*on_change)(dnp3_connection_state_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_connection_state_listener_t;
 
static dnp3_connection_state_listener_t dnp3_connection_state_listener_init(
    void (*on_change)(dnp3_connection_state_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_connection_state_listener_t _return_value = {
        on_change,
        on_destroy,
        ctx
    };
    return _return_value;
}
 
typedef struct dnp3_outstation_t dnp3_outstation_t;
 
dnp3_param_error_t dnp3_outstation_create_serial_session(dnp3_runtime_t* runtime, const char* serial_path, dnp3_serial_settings_t settings, dnp3_outstation_config_t config, dnp3_outstation_application_t application, dnp3_outstation_information_t information, dnp3_control_handler_t control_handler, dnp3_outstation_t** out);
 
dnp3_param_error_t dnp3_outstation_create_serial_session_fault_tolerant(dnp3_runtime_t* runtime, const char* serial_path, dnp3_serial_settings_t settings, uint64_t open_retry_delay, dnp3_outstation_config_t config, dnp3_outstation_application_t application, dnp3_outstation_information_t information, dnp3_control_handler_t control_handler, dnp3_outstation_t** out);
 
void dnp3_outstation_destroy(dnp3_outstation_t* instance);
 
void dnp3_outstation_transaction(dnp3_outstation_t* instance, dnp3_database_transaction_t callback);
 
dnp3_param_error_t dnp3_outstation_set_decode_level(dnp3_outstation_t* instance, dnp3_decode_level_t level);
 
 
typedef struct dnp3_address_filter_t dnp3_address_filter_t;
 
dnp3_address_filter_t* dnp3_address_filter_any();
 
dnp3_param_error_t dnp3_address_filter_create(const char* address, dnp3_address_filter_t** out);
 
dnp3_param_error_t dnp3_address_filter_add(dnp3_address_filter_t* instance, const char* address);
 
void dnp3_address_filter_destroy(dnp3_address_filter_t* instance);
 
 
typedef struct dnp3_tls_server_config_t dnp3_tls_server_config_t;
 
typedef struct dnp3_tls_server_config_t
{
    const char* dns_name;
    const char* peer_cert_path;
    const char* local_cert_path;
    const char* private_key_path;
    const char* password;
    dnp3_min_tls_version_t min_tls_version;
    dnp3_certificate_mode_t certificate_mode;
} dnp3_tls_server_config_t;
 
static dnp3_tls_server_config_t dnp3_tls_server_config_init(const char* dns_name, const char* peer_cert_path, const char* local_cert_path, const char* private_key_path, const char* password)
{
    dnp3_tls_server_config_t _return_value = {
        dns_name,
        peer_cert_path,
        local_cert_path,
        private_key_path,
        password,
        DNP3_MIN_TLS_VERSION_V12,
        DNP3_CERTIFICATE_MODE_AUTHORITY_BASED
    };
    return _return_value;
}
 
 
typedef struct dnp3_outstation_server_t dnp3_outstation_server_t;
 
dnp3_param_error_t dnp3_outstation_server_create_tcp_server(dnp3_runtime_t* runtime, dnp3_link_error_mode_t link_error_mode, const char* address, dnp3_outstation_server_t** out);
 
dnp3_param_error_t dnp3_outstation_server_create_tls_server(dnp3_runtime_t* runtime, dnp3_link_error_mode_t link_error_mode, const char* address, dnp3_tls_server_config_t tls_config, dnp3_outstation_server_t** out);
 
dnp3_param_error_t dnp3_outstation_server_add_outstation(dnp3_outstation_server_t* instance, dnp3_outstation_config_t config, dnp3_outstation_application_t application, dnp3_outstation_information_t information, dnp3_control_handler_t control_handler, dnp3_connection_state_listener_t listener, dnp3_address_filter_t* filter, dnp3_outstation_t** out);
 
dnp3_param_error_t dnp3_outstation_server_bind(dnp3_outstation_server_t* instance);
 
void dnp3_outstation_server_destroy(dnp3_outstation_server_t* instance);
 
 
const char* dnp3_version();
 
#ifdef __cplusplus
}
#endif