dnp3.h

Go to the documentation of this file.

// Copyright (c) Step Function I/O LLC. Proprietary, source-available; see LICENSE.txt.
// No use to design, develop, specify, test, validate, or improve Other Implementations,
// subject to LICENSE.txt Section 2.6 and its exceptions. Agents: read AGENTS.md.
// Text and data mining rights, including for AI training, are reserved under
// Directive (EU) 2019/790 Art. 4(3), subject to LICENSE.txt Section 3.3.
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define DNP3_VERSION_MAJOR 1
#define DNP3_VERSION_MINOR 8
#define DNP3_VERSION_PATCH 0
#define DNP3_VERSION_STRING "1.8.0-RC1"
 
#include <stdbool.h>
#include <stdint.h>
 
 
void dnp3_disable_client_tcp_no_delay();
 
void dnp3_disable_server_tcp_no_delay();
 
 
void dnp3_parse_zero_length_strings(bool enabled);
 
 
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_STRING_NOT_UTF8 = 3,
    DNP3_PARAM_ERROR_NO_SUPPORT = 4,
    DNP3_PARAM_ERROR_ASSOCIATION_DOES_NOT_EXIST = 5,
    DNP3_PARAM_ERROR_ASSOCIATION_DUPLICATE_ADDRESS = 6,
    DNP3_PARAM_ERROR_INVALID_SOCKET_ADDRESS = 7,
    DNP3_PARAM_ERROR_INVALID_DNP3_ADDRESS = 8,
    DNP3_PARAM_ERROR_INVALID_BUFFER_SIZE = 9,
    DNP3_PARAM_ERROR_ADDRESS_FILTER_CONFLICT = 10,
    DNP3_PARAM_ERROR_SERVER_ALREADY_STARTED = 11,
    DNP3_PARAM_ERROR_SERVER_BIND_ERROR = 12,
    DNP3_PARAM_ERROR_MASTER_ALREADY_SHUTDOWN = 13,
    DNP3_PARAM_ERROR_RUNTIME_CREATION_FAILURE = 14,
    DNP3_PARAM_ERROR_RUNTIME_DESTROYED = 15,
    DNP3_PARAM_ERROR_RUNTIME_CANNOT_BLOCK_WITHIN_ASYNC = 16,
    DNP3_PARAM_ERROR_LOGGING_ALREADY_CONFIGURED = 17,
    DNP3_PARAM_ERROR_POINT_DOES_NOT_EXIST = 18,
    DNP3_PARAM_ERROR_INVALID_PEER_CERTIFICATE = 19,
    DNP3_PARAM_ERROR_INVALID_LOCAL_CERTIFICATE = 20,
    DNP3_PARAM_ERROR_INVALID_PRIVATE_KEY = 21,
    DNP3_PARAM_ERROR_INVALID_DNS_NAME = 22,
    DNP3_PARAM_ERROR_OTHER_TLS_ERROR = 23,
    DNP3_PARAM_ERROR_WRONG_CHANNEL_TYPE = 24,
    DNP3_PARAM_ERROR_CONSUMED = 25,
} 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_STRING_NOT_UTF8: return "string_not_utf8";
        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";
        case DNP3_PARAM_ERROR_WRONG_CHANNEL_TYPE: return "wrong_channel_type";
        case DNP3_PARAM_ERROR_CONSUMED: return "consumed";
        default: return "unknown param_error 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";
    }
}
 
#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_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);
 
void dnp3_runtime_set_shutdown_timeout(dnp3_runtime_t* instance, uint64_t timeout);
 
 
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_frozen_analog_input_t dnp3_frozen_analog_input_t;
 
typedef struct dnp3_frozen_analog_input_t
{
    uint16_t index;
    double value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_frozen_analog_input_t;
 
static dnp3_frozen_analog_input_t dnp3_frozen_analog_input_init(uint16_t index, double value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    dnp3_frozen_analog_input_t _return_value = {
        index,
        value,
        flags,
        time
    };
    return _return_value;
}
 
 
typedef struct dnp3_frozen_analog_input_iterator_t dnp3_frozen_analog_input_iterator_t;
 
dnp3_frozen_analog_input_t* dnp3_frozen_analog_input_iterator_next(dnp3_frozen_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_binary_output_command_event_t dnp3_binary_output_command_event_t;
 
typedef struct dnp3_binary_output_command_event_t
{
    uint16_t index;
    dnp3_command_status_t status;
    bool commanded_state;
    dnp3_timestamp_t time;
} dnp3_binary_output_command_event_t;
 
static dnp3_binary_output_command_event_t dnp3_binary_output_command_event_init(uint16_t index, dnp3_command_status_t status, bool commanded_state, dnp3_timestamp_t time)
{
    dnp3_binary_output_command_event_t _return_value = {
        index,
        status,
        commanded_state,
        time
    };
    return _return_value;
}
 
 
typedef struct dnp3_binary_output_command_event_iterator_t dnp3_binary_output_command_event_iterator_t;
 
dnp3_binary_output_command_event_t* dnp3_binary_output_command_event_iterator_next(dnp3_binary_output_command_event_iterator_t* iter);
 
 
typedef enum dnp3_analog_command_type_t
{
    DNP3_ANALOG_COMMAND_TYPE_I16 = 0,
    DNP3_ANALOG_COMMAND_TYPE_I32 = 1,
    DNP3_ANALOG_COMMAND_TYPE_F32 = 2,
    DNP3_ANALOG_COMMAND_TYPE_F64 = 3,
} dnp3_analog_command_type_t;
 
static const char* dnp3_analog_command_type_to_string(dnp3_analog_command_type_t value)
{
    switch (value)
    {
        case DNP3_ANALOG_COMMAND_TYPE_I16: return "i16";
        case DNP3_ANALOG_COMMAND_TYPE_I32: return "i32";
        case DNP3_ANALOG_COMMAND_TYPE_F32: return "f32";
        case DNP3_ANALOG_COMMAND_TYPE_F64: return "f64";
        default: return "unknown analog_command_type value";
    }
}
 
typedef struct dnp3_analog_output_command_event_t dnp3_analog_output_command_event_t;
 
typedef struct dnp3_analog_output_command_event_t
{
    uint16_t index;
    dnp3_command_status_t status;
    double commanded_value;
    dnp3_analog_command_type_t command_type;
    dnp3_timestamp_t time;
} dnp3_analog_output_command_event_t;
 
static dnp3_analog_output_command_event_t dnp3_analog_output_command_event_init(uint16_t index, dnp3_command_status_t status, double commanded_value, dnp3_analog_command_type_t command_type, dnp3_timestamp_t time)
{
    dnp3_analog_output_command_event_t _return_value = {
        index,
        status,
        commanded_value,
        command_type,
        time
    };
    return _return_value;
}
 
 
typedef struct dnp3_analog_output_command_event_iterator_t dnp3_analog_output_command_event_iterator_t;
 
dnp3_analog_output_command_event_t* dnp3_analog_output_command_event_iterator_next(dnp3_analog_output_command_event_iterator_t* iter);
 
 
typedef struct dnp3_unsigned_integer_t dnp3_unsigned_integer_t;
 
typedef struct dnp3_unsigned_integer_t
{
    uint16_t index;
    uint8_t value;
} dnp3_unsigned_integer_t;
 
static dnp3_unsigned_integer_t dnp3_unsigned_integer_init(uint16_t index, uint8_t value)
{
    dnp3_unsigned_integer_t _return_value = {
        index,
        value
    };
    return _return_value;
}
 
 
typedef struct dnp3_unsigned_integer_iterator_t dnp3_unsigned_integer_iterator_t;
 
dnp3_unsigned_integer_t* dnp3_unsigned_integer_iterator_next(dnp3_unsigned_integer_iterator_t* iter);
 
 
typedef struct dnp3_analog_input_dead_band_t dnp3_analog_input_dead_band_t;
 
typedef struct dnp3_analog_input_dead_band_t
{
    uint16_t index;
    double value;
} dnp3_analog_input_dead_band_t;
 
static dnp3_analog_input_dead_band_t dnp3_analog_input_dead_band_init(uint16_t index, double value)
{
    dnp3_analog_input_dead_band_t _return_value = {
        index,
        value
    };
    return _return_value;
}
 
 
typedef struct dnp3_analog_input_dead_band_iterator_t dnp3_analog_input_dead_band_iterator_t;
 
dnp3_analog_input_dead_band_t* dnp3_analog_input_dead_band_iterator_next(dnp3_analog_input_dead_band_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;
 
static dnp3_octet_string_t dnp3_octet_string_init(uint16_t index, dnp3_byte_iterator_t* value)
{
    dnp3_octet_string_t _return_value = {
        index,
        value
    };
    return _return_value;
}
 
 
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 struct dnp3_connect_options_t dnp3_connect_options_t;
 
dnp3_connect_options_t* dnp3_connect_options_create();
 
void dnp3_connect_options_destroy(dnp3_connect_options_t* instance);
 
void dnp3_connect_options_set_timeout(dnp3_connect_options_t* instance, uint64_t timeout);
 
dnp3_param_error_t dnp3_connect_options_set_local_endpoint(dnp3_connect_options_t* instance, const char* endpoint);
 
 
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_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_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 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;
    bool allow_server_name_wildcard;
} 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,
        false
    };
    return _return_value;
}
 
 
#define DNP3_ATTRIBUTE_VARIATIONS_CONFIG_ID 0xC4
#define DNP3_ATTRIBUTE_VARIATIONS_CONFIG_VERSION 0xC5
#define DNP3_ATTRIBUTE_VARIATIONS_CONFIG_BUILD_DATE 0xC6
#define DNP3_ATTRIBUTE_VARIATIONS_CONFIG_LAST_CHANGE_DATE 0xC7
#define DNP3_ATTRIBUTE_VARIATIONS_CONFIG_DIGEST 0xC8
#define DNP3_ATTRIBUTE_VARIATIONS_CONFIG_DIGEST_ALGORITHM 0xC9
#define DNP3_ATTRIBUTE_VARIATIONS_MASTER_RESOURCE_ID 0xCA
#define DNP3_ATTRIBUTE_VARIATIONS_DEVICE_LOCATION_ALTITUDE 0xCB
#define DNP3_ATTRIBUTE_VARIATIONS_DEVICE_LOCATION_LONGITUDE 0xCC
#define DNP3_ATTRIBUTE_VARIATIONS_DEVICE_LOCATION_LATITUDE 0xCD
#define DNP3_ATTRIBUTE_VARIATIONS_USER_ASSIGNED_SECONDARY_OPERATOR_NAME 0xCE
#define DNP3_ATTRIBUTE_VARIATIONS_USER_ASSIGNED_PRIMARY_OPERATOR_NAME 0xCF
#define DNP3_ATTRIBUTE_VARIATIONS_USER_ASSIGNED_SYSTEM_NAME 0xD0
#define DNP3_ATTRIBUTE_VARIATIONS_SECURE_AUTH_VERSION 0xD1
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_SECURITY_STATS_PER_ASSOC 0xD2
#define DNP3_ATTRIBUTE_VARIATIONS_USER_SPECIFIC_ATTRIBUTES 0xD3
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_MASTER_DEFINED_DATA_SET_PROTO 0xD4
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_OUTSTATION_DEFINED_DATA_SET_PROTO 0xD5
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_MASTER_DEFINED_DATA_SETS 0xD6
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_OUTSTATION_DEFINED_DATA_SETS 0xD7
#define DNP3_ATTRIBUTE_VARIATIONS_MAX_BINARY_OUTPUT_PER_REQUEST 0xD8
#define DNP3_ATTRIBUTE_VARIATIONS_LOCAL_TIMING_ACCURACY 0xD9
#define DNP3_ATTRIBUTE_VARIATIONS_DURATION_OF_TIME_ACCURACY 0xDA
#define DNP3_ATTRIBUTE_VARIATIONS_SUPPORTS_ANALOG_OUTPUT_EVENTS 0xDB
#define DNP3_ATTRIBUTE_VARIATIONS_MAX_ANALOG_OUTPUT_INDEX 0xDC
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_ANALOG_OUTPUTS 0xDD
#define DNP3_ATTRIBUTE_VARIATIONS_SUPPORTS_BINARY_OUTPUT_EVENTS 0xDE
#define DNP3_ATTRIBUTE_VARIATIONS_MAX_BINARY_OUTPUT_INDEX 0xDF
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_BINARY_OUTPUTS 0xE0
#define DNP3_ATTRIBUTE_VARIATIONS_SUPPORTS_FROZEN_COUNTER_EVENTS 0xE1
#define DNP3_ATTRIBUTE_VARIATIONS_SUPPORTS_FROZEN_COUNTERS 0xE2
#define DNP3_ATTRIBUTE_VARIATIONS_SUPPORTS_COUNTER_EVENTS 0xE3
#define DNP3_ATTRIBUTE_VARIATIONS_MAX_COUNTER_INDEX 0xE4
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_COUNTER 0xE5
#define DNP3_ATTRIBUTE_VARIATIONS_SUPPORTS_FROZEN_ANALOG_INPUTS 0xE6
#define DNP3_ATTRIBUTE_VARIATIONS_SUPPORTS_ANALOG_INPUT_EVENTS 0xE7
#define DNP3_ATTRIBUTE_VARIATIONS_MAX_ANALOG_INPUT_INDEX 0xE8
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_ANALOG_INPUT 0xE9
#define DNP3_ATTRIBUTE_VARIATIONS_SUPPORTS_DOUBLE_BIT_BINARY_INPUT_EVENTS 0xEA
#define DNP3_ATTRIBUTE_VARIATIONS_MAX_DOUBLE_BIT_BINARY_INPUT_INDEX 0xEB
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_DOUBLE_BIT_BINARY_INPUT 0xEC
#define DNP3_ATTRIBUTE_VARIATIONS_SUPPORTS_BINARY_INPUT_EVENTS 0xED
#define DNP3_ATTRIBUTE_VARIATIONS_MAX_BINARY_INPUT_INDEX 0xEE
#define DNP3_ATTRIBUTE_VARIATIONS_NUM_BINARY_INPUT 0xEF
#define DNP3_ATTRIBUTE_VARIATIONS_MAX_TX_FRAGMENT_SIZE 0xF0
#define DNP3_ATTRIBUTE_VARIATIONS_MAX_RX_FRAGMENT_SIZE 0xF1
#define DNP3_ATTRIBUTE_VARIATIONS_DEVICE_MANUFACTURER_SOFTWARE_VERSION 0xF2
#define DNP3_ATTRIBUTE_VARIATIONS_DEVICE_MANUFACTURER_HARDWARE_VERSION 0xF3
#define DNP3_ATTRIBUTE_VARIATIONS_USER_ASSIGNED_OWNER_NAME 0xF4
#define DNP3_ATTRIBUTE_VARIATIONS_USER_ASSIGNED_LOCATION 0xF5
#define DNP3_ATTRIBUTE_VARIATIONS_USER_ASSIGNED_ID 0xF6
#define DNP3_ATTRIBUTE_VARIATIONS_USER_ASSIGNED_DEVICE_NAME 0xF7
#define DNP3_ATTRIBUTE_VARIATIONS_DEVICE_SERIAL_NUMBER 0xF8
#define DNP3_ATTRIBUTE_VARIATIONS_DEVICE_SUBSET_AND_CONFORMANCE 0xF9
#define DNP3_ATTRIBUTE_VARIATIONS_PRODUCT_NAME_AND_MODEL 0xFA
#define DNP3_ATTRIBUTE_VARIATIONS_DEVICE_MANUFACTURERS_NAME 0xFC
#define DNP3_ATTRIBUTE_VARIATIONS_ALL_ATTRIBUTES_REQUEST 0xFE
#define DNP3_ATTRIBUTE_VARIATIONS_LIST_OF_VARIATIONS 0xFF
 
typedef enum dnp3_variation_list_attr_t
{
    DNP3_VARIATION_LIST_ATTR_UNKNOWN = 0,
    DNP3_VARIATION_LIST_ATTR_LIST_OF_VARIATIONS = 1,
} dnp3_variation_list_attr_t;
 
static const char* dnp3_variation_list_attr_to_string(dnp3_variation_list_attr_t value)
{
    switch (value)
    {
        case DNP3_VARIATION_LIST_ATTR_UNKNOWN: return "unknown";
        case DNP3_VARIATION_LIST_ATTR_LIST_OF_VARIATIONS: return "list_of_variations";
        default: return "unknown variation_list_attr value";
    }
}
 
typedef enum dnp3_string_attr_t
{
    DNP3_STRING_ATTR_UNKNOWN = 0,
    DNP3_STRING_ATTR_CONFIG_ID = 1,
    DNP3_STRING_ATTR_CONFIG_VERSION = 2,
    DNP3_STRING_ATTR_CONFIG_DIGEST_ALGORITHM = 3,
    DNP3_STRING_ATTR_MASTER_RESOURCE_ID = 4,
    DNP3_STRING_ATTR_USER_ASSIGNED_SECONDARY_OPERATOR_NAME = 5,
    DNP3_STRING_ATTR_USER_ASSIGNED_PRIMARY_OPERATOR_NAME = 6,
    DNP3_STRING_ATTR_USER_ASSIGNED_SYSTEM_NAME = 7,
    DNP3_STRING_ATTR_USER_SPECIFIC_ATTRIBUTES = 8,
    DNP3_STRING_ATTR_DEVICE_MANUFACTURER_SOFTWARE_VERSION = 9,
    DNP3_STRING_ATTR_DEVICE_MANUFACTURER_HARDWARE_VERSION = 10,
    DNP3_STRING_ATTR_USER_ASSIGNED_OWNER_NAME = 11,
    DNP3_STRING_ATTR_USER_ASSIGNED_LOCATION = 12,
    DNP3_STRING_ATTR_USER_ASSIGNED_ID = 13,
    DNP3_STRING_ATTR_USER_ASSIGNED_DEVICE_NAME = 14,
    DNP3_STRING_ATTR_DEVICE_SERIAL_NUMBER = 15,
    DNP3_STRING_ATTR_DEVICE_SUBSET_AND_CONFORMANCE = 16,
    DNP3_STRING_ATTR_PRODUCT_NAME_AND_MODEL = 17,
    DNP3_STRING_ATTR_DEVICE_MANUFACTURERS_NAME = 18,
} dnp3_string_attr_t;
 
static const char* dnp3_string_attr_to_string(dnp3_string_attr_t value)
{
    switch (value)
    {
        case DNP3_STRING_ATTR_UNKNOWN: return "unknown";
        case DNP3_STRING_ATTR_CONFIG_ID: return "config_id";
        case DNP3_STRING_ATTR_CONFIG_VERSION: return "config_version";
        case DNP3_STRING_ATTR_CONFIG_DIGEST_ALGORITHM: return "config_digest_algorithm";
        case DNP3_STRING_ATTR_MASTER_RESOURCE_ID: return "master_resource_id";
        case DNP3_STRING_ATTR_USER_ASSIGNED_SECONDARY_OPERATOR_NAME: return "user_assigned_secondary_operator_name";
        case DNP3_STRING_ATTR_USER_ASSIGNED_PRIMARY_OPERATOR_NAME: return "user_assigned_primary_operator_name";
        case DNP3_STRING_ATTR_USER_ASSIGNED_SYSTEM_NAME: return "user_assigned_system_name";
        case DNP3_STRING_ATTR_USER_SPECIFIC_ATTRIBUTES: return "user_specific_attributes";
        case DNP3_STRING_ATTR_DEVICE_MANUFACTURER_SOFTWARE_VERSION: return "device_manufacturer_software_version";
        case DNP3_STRING_ATTR_DEVICE_MANUFACTURER_HARDWARE_VERSION: return "device_manufacturer_hardware_version";
        case DNP3_STRING_ATTR_USER_ASSIGNED_OWNER_NAME: return "user_assigned_owner_name";
        case DNP3_STRING_ATTR_USER_ASSIGNED_LOCATION: return "user_assigned_location";
        case DNP3_STRING_ATTR_USER_ASSIGNED_ID: return "user_assigned_id";
        case DNP3_STRING_ATTR_USER_ASSIGNED_DEVICE_NAME: return "user_assigned_device_name";
        case DNP3_STRING_ATTR_DEVICE_SERIAL_NUMBER: return "device_serial_number";
        case DNP3_STRING_ATTR_DEVICE_SUBSET_AND_CONFORMANCE: return "device_subset_and_conformance";
        case DNP3_STRING_ATTR_PRODUCT_NAME_AND_MODEL: return "product_name_and_model";
        case DNP3_STRING_ATTR_DEVICE_MANUFACTURERS_NAME: return "device_manufacturers_name";
        default: return "unknown string_attr value";
    }
}
 
typedef enum dnp3_uint_attr_t
{
    DNP3_UINT_ATTR_UNKNOWN = 0,
    DNP3_UINT_ATTR_SECURE_AUTH_VERSION = 1,
    DNP3_UINT_ATTR_NUM_SECURITY_STATS_PER_ASSOC = 2,
    DNP3_UINT_ATTR_NUM_MASTER_DEFINED_DATA_SET_PROTO = 3,
    DNP3_UINT_ATTR_NUM_OUTSTATION_DEFINED_DATA_SET_PROTO = 4,
    DNP3_UINT_ATTR_NUM_MASTER_DEFINED_DATA_SETS = 5,
    DNP3_UINT_ATTR_NUM_OUTSTATION_DEFINED_DATA_SETS = 6,
    DNP3_UINT_ATTR_MAX_BINARY_OUTPUT_PER_REQUEST = 7,
    DNP3_UINT_ATTR_LOCAL_TIMING_ACCURACY = 8,
    DNP3_UINT_ATTR_DURATION_OF_TIME_ACCURACY = 9,
    DNP3_UINT_ATTR_MAX_ANALOG_OUTPUT_INDEX = 10,
    DNP3_UINT_ATTR_NUM_ANALOG_OUTPUTS = 11,
    DNP3_UINT_ATTR_MAX_BINARY_OUTPUT_INDEX = 12,
    DNP3_UINT_ATTR_NUM_BINARY_OUTPUTS = 13,
    DNP3_UINT_ATTR_MAX_COUNTER_INDEX = 14,
    DNP3_UINT_ATTR_NUM_COUNTER = 15,
    DNP3_UINT_ATTR_MAX_ANALOG_INPUT_INDEX = 16,
    DNP3_UINT_ATTR_NUM_ANALOG_INPUT = 17,
    DNP3_UINT_ATTR_MAX_DOUBLE_BIT_BINARY_INPUT_INDEX = 18,
    DNP3_UINT_ATTR_NUM_DOUBLE_BIT_BINARY_INPUT = 19,
    DNP3_UINT_ATTR_MAX_BINARY_INPUT_INDEX = 20,
    DNP3_UINT_ATTR_NUM_BINARY_INPUT = 21,
    DNP3_UINT_ATTR_MAX_TX_FRAGMENT_SIZE = 22,
    DNP3_UINT_ATTR_MAX_RX_FRAGMENT_SIZE = 23,
} dnp3_uint_attr_t;
 
static const char* dnp3_uint_attr_to_string(dnp3_uint_attr_t value)
{
    switch (value)
    {
        case DNP3_UINT_ATTR_UNKNOWN: return "unknown";
        case DNP3_UINT_ATTR_SECURE_AUTH_VERSION: return "secure_auth_version";
        case DNP3_UINT_ATTR_NUM_SECURITY_STATS_PER_ASSOC: return "num_security_stats_per_assoc";
        case DNP3_UINT_ATTR_NUM_MASTER_DEFINED_DATA_SET_PROTO: return "num_master_defined_data_set_proto";
        case DNP3_UINT_ATTR_NUM_OUTSTATION_DEFINED_DATA_SET_PROTO: return "num_outstation_defined_data_set_proto";
        case DNP3_UINT_ATTR_NUM_MASTER_DEFINED_DATA_SETS: return "num_master_defined_data_sets";
        case DNP3_UINT_ATTR_NUM_OUTSTATION_DEFINED_DATA_SETS: return "num_outstation_defined_data_sets";
        case DNP3_UINT_ATTR_MAX_BINARY_OUTPUT_PER_REQUEST: return "max_binary_output_per_request";
        case DNP3_UINT_ATTR_LOCAL_TIMING_ACCURACY: return "local_timing_accuracy";
        case DNP3_UINT_ATTR_DURATION_OF_TIME_ACCURACY: return "duration_of_time_accuracy";
        case DNP3_UINT_ATTR_MAX_ANALOG_OUTPUT_INDEX: return "max_analog_output_index";
        case DNP3_UINT_ATTR_NUM_ANALOG_OUTPUTS: return "num_analog_outputs";
        case DNP3_UINT_ATTR_MAX_BINARY_OUTPUT_INDEX: return "max_binary_output_index";
        case DNP3_UINT_ATTR_NUM_BINARY_OUTPUTS: return "num_binary_outputs";
        case DNP3_UINT_ATTR_MAX_COUNTER_INDEX: return "max_counter_index";
        case DNP3_UINT_ATTR_NUM_COUNTER: return "num_counter";
        case DNP3_UINT_ATTR_MAX_ANALOG_INPUT_INDEX: return "max_analog_input_index";
        case DNP3_UINT_ATTR_NUM_ANALOG_INPUT: return "num_analog_input";
        case DNP3_UINT_ATTR_MAX_DOUBLE_BIT_BINARY_INPUT_INDEX: return "max_double_bit_binary_input_index";
        case DNP3_UINT_ATTR_NUM_DOUBLE_BIT_BINARY_INPUT: return "num_double_bit_binary_input";
        case DNP3_UINT_ATTR_MAX_BINARY_INPUT_INDEX: return "max_binary_input_index";
        case DNP3_UINT_ATTR_NUM_BINARY_INPUT: return "num_binary_input";
        case DNP3_UINT_ATTR_MAX_TX_FRAGMENT_SIZE: return "max_tx_fragment_size";
        case DNP3_UINT_ATTR_MAX_RX_FRAGMENT_SIZE: return "max_rx_fragment_size";
        default: return "unknown uint_attr value";
    }
}
 
typedef enum dnp3_int_attr_t
{
    DNP3_INT_ATTR_UNKNOWN = 0,
} dnp3_int_attr_t;
 
static const char* dnp3_int_attr_to_string(dnp3_int_attr_t value)
{
    switch (value)
    {
        case DNP3_INT_ATTR_UNKNOWN: return "unknown";
        default: return "unknown int_attr value";
    }
}
 
typedef enum dnp3_bool_attr_t
{
    DNP3_BOOL_ATTR_UNKNOWN = 0,
    DNP3_BOOL_ATTR_SUPPORTS_ANALOG_OUTPUT_EVENTS = 1,
    DNP3_BOOL_ATTR_SUPPORTS_BINARY_OUTPUT_EVENTS = 2,
    DNP3_BOOL_ATTR_SUPPORTS_FROZEN_COUNTER_EVENTS = 3,
    DNP3_BOOL_ATTR_SUPPORTS_FROZEN_COUNTERS = 4,
    DNP3_BOOL_ATTR_SUPPORTS_COUNTER_EVENTS = 5,
    DNP3_BOOL_ATTR_SUPPORTS_FROZEN_ANALOG_INPUTS = 6,
    DNP3_BOOL_ATTR_SUPPORTS_ANALOG_INPUT_EVENTS = 7,
    DNP3_BOOL_ATTR_SUPPORTS_DOUBLE_BIT_BINARY_INPUT_EVENTS = 8,
    DNP3_BOOL_ATTR_SUPPORTS_BINARY_INPUT_EVENTS = 9,
} dnp3_bool_attr_t;
 
static const char* dnp3_bool_attr_to_string(dnp3_bool_attr_t value)
{
    switch (value)
    {
        case DNP3_BOOL_ATTR_UNKNOWN: return "unknown";
        case DNP3_BOOL_ATTR_SUPPORTS_ANALOG_OUTPUT_EVENTS: return "supports_analog_output_events";
        case DNP3_BOOL_ATTR_SUPPORTS_BINARY_OUTPUT_EVENTS: return "supports_binary_output_events";
        case DNP3_BOOL_ATTR_SUPPORTS_FROZEN_COUNTER_EVENTS: return "supports_frozen_counter_events";
        case DNP3_BOOL_ATTR_SUPPORTS_FROZEN_COUNTERS: return "supports_frozen_counters";
        case DNP3_BOOL_ATTR_SUPPORTS_COUNTER_EVENTS: return "supports_counter_events";
        case DNP3_BOOL_ATTR_SUPPORTS_FROZEN_ANALOG_INPUTS: return "supports_frozen_analog_inputs";
        case DNP3_BOOL_ATTR_SUPPORTS_ANALOG_INPUT_EVENTS: return "supports_analog_input_events";
        case DNP3_BOOL_ATTR_SUPPORTS_DOUBLE_BIT_BINARY_INPUT_EVENTS: return "supports_double_bit_binary_input_events";
        case DNP3_BOOL_ATTR_SUPPORTS_BINARY_INPUT_EVENTS: return "supports_binary_input_events";
        default: return "unknown bool_attr value";
    }
}
 
typedef enum dnp3_time_attr_t
{
    DNP3_TIME_ATTR_UNKNOWN = 0,
    DNP3_TIME_ATTR_CONFIG_BUILD_DATE = 1,
    DNP3_TIME_ATTR_CONFIG_LAST_CHANGE_DATE = 2,
} dnp3_time_attr_t;
 
static const char* dnp3_time_attr_to_string(dnp3_time_attr_t value)
{
    switch (value)
    {
        case DNP3_TIME_ATTR_UNKNOWN: return "unknown";
        case DNP3_TIME_ATTR_CONFIG_BUILD_DATE: return "config_build_date";
        case DNP3_TIME_ATTR_CONFIG_LAST_CHANGE_DATE: return "config_last_change_date";
        default: return "unknown time_attr value";
    }
}
 
typedef enum dnp3_octet_string_attr_t
{
    DNP3_OCTET_STRING_ATTR_UNKNOWN = 0,
    DNP3_OCTET_STRING_ATTR_CONFIG_DIGEST = 1,
} dnp3_octet_string_attr_t;
 
static const char* dnp3_octet_string_attr_to_string(dnp3_octet_string_attr_t value)
{
    switch (value)
    {
        case DNP3_OCTET_STRING_ATTR_UNKNOWN: return "unknown";
        case DNP3_OCTET_STRING_ATTR_CONFIG_DIGEST: return "config_digest";
        default: return "unknown octet_string_attr value";
    }
}
 
typedef enum dnp3_bit_string_attr_t
{
    DNP3_BIT_STRING_ATTR_UNKNOWN = 0,
} dnp3_bit_string_attr_t;
 
static const char* dnp3_bit_string_attr_to_string(dnp3_bit_string_attr_t value)
{
    switch (value)
    {
        case DNP3_BIT_STRING_ATTR_UNKNOWN: return "unknown";
        default: return "unknown bit_string_attr value";
    }
}
 
typedef enum dnp3_float_attr_t
{
    DNP3_FLOAT_ATTR_UNKNOWN = 0,
    DNP3_FLOAT_ATTR_DEVICE_LOCATION_ALTITUDE = 1,
    DNP3_FLOAT_ATTR_DEVICE_LOCATION_LONGITUDE = 2,
    DNP3_FLOAT_ATTR_DEVICE_LOCATION_LATITUDE = 3,
} dnp3_float_attr_t;
 
static const char* dnp3_float_attr_to_string(dnp3_float_attr_t value)
{
    switch (value)
    {
        case DNP3_FLOAT_ATTR_UNKNOWN: return "unknown";
        case DNP3_FLOAT_ATTR_DEVICE_LOCATION_ALTITUDE: return "device_location_altitude";
        case DNP3_FLOAT_ATTR_DEVICE_LOCATION_LONGITUDE: return "device_location_longitude";
        case DNP3_FLOAT_ATTR_DEVICE_LOCATION_LATITUDE: return "device_location_latitude";
        default: return "unknown float_attr value";
    }
}
 
typedef struct dnp3_attr_prop_t dnp3_attr_prop_t;
 
typedef struct dnp3_attr_prop_t
{
    bool is_writable;
} dnp3_attr_prop_t;
 
 
typedef struct dnp3_attr_item_t dnp3_attr_item_t;
 
typedef struct dnp3_attr_item_t
{
    uint8_t variation;
    dnp3_attr_prop_t properties;
} dnp3_attr_item_t;
 
 
typedef struct dnp3_attr_item_iter_t dnp3_attr_item_iter_t;
 
dnp3_attr_item_t* dnp3_attr_item_iter_next(dnp3_attr_item_iter_t* iter);
 
 
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";
    }
}
 
typedef struct dnp3_byte_collection_t dnp3_byte_collection_t;
 
dnp3_byte_collection_t* dnp3_byte_collection_create(uint32_t reserve_size);
 
void dnp3_byte_collection_destroy(dnp3_byte_collection_t* instance);
 
void dnp3_byte_collection_add(dnp3_byte_collection_t* instance, uint8_t value);
 
 
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;
 
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;
 
typedef enum dnp3_variation_t
{
    DNP3_VARIATION_GROUP0 = 0,
    DNP3_VARIATION_GROUP0_VAR254 = 1,
    DNP3_VARIATION_GROUP1_VAR0 = 2,
    DNP3_VARIATION_GROUP1_VAR1 = 3,
    DNP3_VARIATION_GROUP1_VAR2 = 4,
    DNP3_VARIATION_GROUP2_VAR0 = 5,
    DNP3_VARIATION_GROUP2_VAR1 = 6,
    DNP3_VARIATION_GROUP2_VAR2 = 7,
    DNP3_VARIATION_GROUP2_VAR3 = 8,
    DNP3_VARIATION_GROUP3_VAR0 = 9,
    DNP3_VARIATION_GROUP3_VAR1 = 10,
    DNP3_VARIATION_GROUP3_VAR2 = 11,
    DNP3_VARIATION_GROUP4_VAR0 = 12,
    DNP3_VARIATION_GROUP4_VAR1 = 13,
    DNP3_VARIATION_GROUP4_VAR2 = 14,
    DNP3_VARIATION_GROUP4_VAR3 = 15,
    DNP3_VARIATION_GROUP10_VAR0 = 16,
    DNP3_VARIATION_GROUP10_VAR1 = 17,
    DNP3_VARIATION_GROUP10_VAR2 = 18,
    DNP3_VARIATION_GROUP11_VAR0 = 19,
    DNP3_VARIATION_GROUP11_VAR1 = 20,
    DNP3_VARIATION_GROUP11_VAR2 = 21,
    DNP3_VARIATION_GROUP12_VAR1 = 22,
    DNP3_VARIATION_GROUP13_VAR1 = 23,
    DNP3_VARIATION_GROUP13_VAR2 = 24,
    DNP3_VARIATION_GROUP20_VAR0 = 25,
    DNP3_VARIATION_GROUP20_VAR1 = 26,
    DNP3_VARIATION_GROUP20_VAR2 = 27,
    DNP3_VARIATION_GROUP20_VAR5 = 28,
    DNP3_VARIATION_GROUP20_VAR6 = 29,
    DNP3_VARIATION_GROUP21_VAR0 = 30,
    DNP3_VARIATION_GROUP21_VAR1 = 31,
    DNP3_VARIATION_GROUP21_VAR2 = 32,
    DNP3_VARIATION_GROUP21_VAR5 = 33,
    DNP3_VARIATION_GROUP21_VAR6 = 34,
    DNP3_VARIATION_GROUP21_VAR9 = 35,
    DNP3_VARIATION_GROUP21_VAR10 = 36,
    DNP3_VARIATION_GROUP22_VAR0 = 37,
    DNP3_VARIATION_GROUP22_VAR1 = 38,
    DNP3_VARIATION_GROUP22_VAR2 = 39,
    DNP3_VARIATION_GROUP22_VAR5 = 40,
    DNP3_VARIATION_GROUP22_VAR6 = 41,
    DNP3_VARIATION_GROUP23_VAR0 = 42,
    DNP3_VARIATION_GROUP23_VAR1 = 43,
    DNP3_VARIATION_GROUP23_VAR2 = 44,
    DNP3_VARIATION_GROUP23_VAR5 = 45,
    DNP3_VARIATION_GROUP23_VAR6 = 46,
    DNP3_VARIATION_GROUP30_VAR0 = 47,
    DNP3_VARIATION_GROUP30_VAR1 = 48,
    DNP3_VARIATION_GROUP30_VAR2 = 49,
    DNP3_VARIATION_GROUP30_VAR3 = 50,
    DNP3_VARIATION_GROUP30_VAR4 = 51,
    DNP3_VARIATION_GROUP30_VAR5 = 52,
    DNP3_VARIATION_GROUP30_VAR6 = 53,
    DNP3_VARIATION_GROUP31_VAR0 = 54,
    DNP3_VARIATION_GROUP31_VAR1 = 55,
    DNP3_VARIATION_GROUP31_VAR2 = 56,
    DNP3_VARIATION_GROUP31_VAR3 = 57,
    DNP3_VARIATION_GROUP31_VAR4 = 58,
    DNP3_VARIATION_GROUP31_VAR5 = 59,
    DNP3_VARIATION_GROUP31_VAR6 = 60,
    DNP3_VARIATION_GROUP31_VAR7 = 61,
    DNP3_VARIATION_GROUP31_VAR8 = 62,
    DNP3_VARIATION_GROUP32_VAR0 = 63,
    DNP3_VARIATION_GROUP32_VAR1 = 64,
    DNP3_VARIATION_GROUP32_VAR2 = 65,
    DNP3_VARIATION_GROUP32_VAR3 = 66,
    DNP3_VARIATION_GROUP32_VAR4 = 67,
    DNP3_VARIATION_GROUP32_VAR5 = 68,
    DNP3_VARIATION_GROUP32_VAR6 = 69,
    DNP3_VARIATION_GROUP32_VAR7 = 70,
    DNP3_VARIATION_GROUP32_VAR8 = 71,
    DNP3_VARIATION_GROUP33_VAR0 = 72,
    DNP3_VARIATION_GROUP33_VAR1 = 73,
    DNP3_VARIATION_GROUP33_VAR2 = 74,
    DNP3_VARIATION_GROUP33_VAR3 = 75,
    DNP3_VARIATION_GROUP33_VAR4 = 76,
    DNP3_VARIATION_GROUP33_VAR5 = 77,
    DNP3_VARIATION_GROUP33_VAR6 = 78,
    DNP3_VARIATION_GROUP33_VAR7 = 79,
    DNP3_VARIATION_GROUP33_VAR8 = 80,
    DNP3_VARIATION_GROUP34_VAR0 = 81,
    DNP3_VARIATION_GROUP34_VAR1 = 82,
    DNP3_VARIATION_GROUP34_VAR2 = 83,
    DNP3_VARIATION_GROUP34_VAR3 = 84,
    DNP3_VARIATION_GROUP40_VAR0 = 85,
    DNP3_VARIATION_GROUP40_VAR1 = 86,
    DNP3_VARIATION_GROUP40_VAR2 = 87,
    DNP3_VARIATION_GROUP40_VAR3 = 88,
    DNP3_VARIATION_GROUP40_VAR4 = 89,
    DNP3_VARIATION_GROUP41_VAR1 = 90,
    DNP3_VARIATION_GROUP41_VAR2 = 91,
    DNP3_VARIATION_GROUP41_VAR3 = 92,
    DNP3_VARIATION_GROUP41_VAR4 = 93,
    DNP3_VARIATION_GROUP42_VAR0 = 94,
    DNP3_VARIATION_GROUP42_VAR1 = 95,
    DNP3_VARIATION_GROUP42_VAR2 = 96,
    DNP3_VARIATION_GROUP42_VAR3 = 97,
    DNP3_VARIATION_GROUP42_VAR4 = 98,
    DNP3_VARIATION_GROUP42_VAR5 = 99,
    DNP3_VARIATION_GROUP42_VAR6 = 100,
    DNP3_VARIATION_GROUP42_VAR7 = 101,
    DNP3_VARIATION_GROUP42_VAR8 = 102,
    DNP3_VARIATION_GROUP43_VAR1 = 103,
    DNP3_VARIATION_GROUP43_VAR2 = 104,
    DNP3_VARIATION_GROUP43_VAR3 = 105,
    DNP3_VARIATION_GROUP43_VAR4 = 106,
    DNP3_VARIATION_GROUP43_VAR5 = 107,
    DNP3_VARIATION_GROUP43_VAR6 = 108,
    DNP3_VARIATION_GROUP43_VAR7 = 109,
    DNP3_VARIATION_GROUP43_VAR8 = 110,
    DNP3_VARIATION_GROUP50_VAR1 = 111,
    DNP3_VARIATION_GROUP50_VAR2 = 112,
    DNP3_VARIATION_GROUP50_VAR3 = 113,
    DNP3_VARIATION_GROUP50_VAR4 = 114,
    DNP3_VARIATION_GROUP51_VAR1 = 115,
    DNP3_VARIATION_GROUP51_VAR2 = 116,
    DNP3_VARIATION_GROUP52_VAR1 = 117,
    DNP3_VARIATION_GROUP52_VAR2 = 118,
    DNP3_VARIATION_GROUP60_VAR1 = 119,
    DNP3_VARIATION_GROUP60_VAR2 = 120,
    DNP3_VARIATION_GROUP60_VAR3 = 121,
    DNP3_VARIATION_GROUP60_VAR4 = 122,
    DNP3_VARIATION_GROUP70_VAR2 = 123,
    DNP3_VARIATION_GROUP70_VAR3 = 124,
    DNP3_VARIATION_GROUP70_VAR4 = 125,
    DNP3_VARIATION_GROUP70_VAR5 = 126,
    DNP3_VARIATION_GROUP70_VAR6 = 127,
    DNP3_VARIATION_GROUP70_VAR7 = 128,
    DNP3_VARIATION_GROUP70_VAR8 = 129,
    DNP3_VARIATION_GROUP80_VAR1 = 130,
    DNP3_VARIATION_GROUP102_VAR0 = 131,
    DNP3_VARIATION_GROUP102_VAR1 = 132,
    DNP3_VARIATION_GROUP110 = 133,
    DNP3_VARIATION_GROUP111 = 134,
} dnp3_variation_t;
 
static const char* dnp3_variation_to_string(dnp3_variation_t value)
{
    switch (value)
    {
        case DNP3_VARIATION_GROUP0: return "group0";
        case DNP3_VARIATION_GROUP0_VAR254: return "group0_var254";
        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_VAR1: return "group12_var1";
        case DNP3_VARIATION_GROUP13_VAR1: return "group13_var1";
        case DNP3_VARIATION_GROUP13_VAR2: return "group13_var2";
        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_GROUP31_VAR0: return "group31_var0";
        case DNP3_VARIATION_GROUP31_VAR1: return "group31_var1";
        case DNP3_VARIATION_GROUP31_VAR2: return "group31_var2";
        case DNP3_VARIATION_GROUP31_VAR3: return "group31_var3";
        case DNP3_VARIATION_GROUP31_VAR4: return "group31_var4";
        case DNP3_VARIATION_GROUP31_VAR5: return "group31_var5";
        case DNP3_VARIATION_GROUP31_VAR6: return "group31_var6";
        case DNP3_VARIATION_GROUP31_VAR7: return "group31_var7";
        case DNP3_VARIATION_GROUP31_VAR8: return "group31_var8";
        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_GROUP33_VAR0: return "group33_var0";
        case DNP3_VARIATION_GROUP33_VAR1: return "group33_var1";
        case DNP3_VARIATION_GROUP33_VAR2: return "group33_var2";
        case DNP3_VARIATION_GROUP33_VAR3: return "group33_var3";
        case DNP3_VARIATION_GROUP33_VAR4: return "group33_var4";
        case DNP3_VARIATION_GROUP33_VAR5: return "group33_var5";
        case DNP3_VARIATION_GROUP33_VAR6: return "group33_var6";
        case DNP3_VARIATION_GROUP33_VAR7: return "group33_var7";
        case DNP3_VARIATION_GROUP33_VAR8: return "group33_var8";
        case DNP3_VARIATION_GROUP34_VAR0: return "group34_var0";
        case DNP3_VARIATION_GROUP34_VAR1: return "group34_var1";
        case DNP3_VARIATION_GROUP34_VAR2: return "group34_var2";
        case DNP3_VARIATION_GROUP34_VAR3: return "group34_var3";
        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_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_GROUP43_VAR1: return "group43_var1";
        case DNP3_VARIATION_GROUP43_VAR2: return "group43_var2";
        case DNP3_VARIATION_GROUP43_VAR3: return "group43_var3";
        case DNP3_VARIATION_GROUP43_VAR4: return "group43_var4";
        case DNP3_VARIATION_GROUP43_VAR5: return "group43_var5";
        case DNP3_VARIATION_GROUP43_VAR6: return "group43_var6";
        case DNP3_VARIATION_GROUP43_VAR7: return "group43_var7";
        case DNP3_VARIATION_GROUP43_VAR8: return "group43_var8";
        case DNP3_VARIATION_GROUP50_VAR1: return "group50_var1";
        case DNP3_VARIATION_GROUP50_VAR2: return "group50_var2";
        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_GROUP70_VAR2: return "group70_var2";
        case DNP3_VARIATION_GROUP70_VAR3: return "group70_var3";
        case DNP3_VARIATION_GROUP70_VAR4: return "group70_var4";
        case DNP3_VARIATION_GROUP70_VAR5: return "group70_var5";
        case DNP3_VARIATION_GROUP70_VAR6: return "group70_var6";
        case DNP3_VARIATION_GROUP70_VAR7: return "group70_var7";
        case DNP3_VARIATION_GROUP70_VAR8: return "group70_var8";
        case DNP3_VARIATION_GROUP80_VAR1: return "group80_var1";
        case DNP3_VARIATION_GROUP102_VAR0: return "group102_var0";
        case DNP3_VARIATION_GROUP102_VAR1: return "group102_var1";
        case DNP3_VARIATION_GROUP110: return "group110";
        case DNP3_VARIATION_GROUP111: return "group111";
        default: return "unknown variation value";
    }
}
 
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 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 struct dnp3_class_count_t dnp3_class_count_t;
 
typedef struct dnp3_class_count_t
{
    uint32_t num_class_1;
    uint32_t num_class_2;
    uint32_t num_class_3;
} dnp3_class_count_t;
 
 
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_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_file_type_t
{
    DNP3_FILE_TYPE_DIRECTORY = 0,
    DNP3_FILE_TYPE_SIMPLE = 1,
    DNP3_FILE_TYPE_OTHER = 2,
} dnp3_file_type_t;
 
static const char* dnp3_file_type_to_string(dnp3_file_type_t value)
{
    switch (value)
    {
        case DNP3_FILE_TYPE_DIRECTORY: return "directory";
        case DNP3_FILE_TYPE_SIMPLE: return "simple";
        case DNP3_FILE_TYPE_OTHER: return "other";
        default: return "unknown file_type value";
    }
}
 
typedef struct dnp3_permission_set_t dnp3_permission_set_t;
 
typedef struct dnp3_permission_set_t
{
    bool execute;
    bool write;
    bool read;
} dnp3_permission_set_t;
 
static dnp3_permission_set_t dnp3_permission_set_init(bool execute, bool write, bool read)
{
    dnp3_permission_set_t _return_value = {
        execute,
        write,
        read
    };
    return _return_value;
}
 
static dnp3_permission_set_t dnp3_permission_set_none()
{
    dnp3_permission_set_t _return_value = {
        false,
        false,
        false
    };
    return _return_value;
}
 
 
typedef struct dnp3_permissions_t dnp3_permissions_t;
 
typedef struct dnp3_permissions_t
{
    dnp3_permission_set_t world;
    dnp3_permission_set_t group;
    dnp3_permission_set_t owner;
} dnp3_permissions_t;
 
static dnp3_permissions_t dnp3_permissions_init(dnp3_permission_set_t world, dnp3_permission_set_t group, dnp3_permission_set_t owner)
{
    dnp3_permissions_t _return_value = {
        world,
        group,
        owner
    };
    return _return_value;
}
 
static dnp3_permissions_t dnp3_permissions_none()
{
    dnp3_permissions_t _return_value = {
        dnp3_permission_set_none(),
        dnp3_permission_set_none(),
        dnp3_permission_set_none()
    };
    return _return_value;
}
 
 
typedef struct dnp3_open_file_t dnp3_open_file_t;
 
typedef struct dnp3_open_file_t
{
    uint32_t file_handle;
    uint32_t file_size;
    uint16_t max_block_size;
} dnp3_open_file_t;
 
 
typedef enum dnp3_file_error_t
{
    DNP3_FILE_ERROR_OK = 0,
    DNP3_FILE_ERROR_BAD_STATUS = 1,
    DNP3_FILE_ERROR_NO_PERMISSION = 2,
    DNP3_FILE_ERROR_BAD_BLOCK_NUM = 3,
    DNP3_FILE_ERROR_ABORT_BY_USER = 4,
    DNP3_FILE_ERROR_MAX_LENGTH_EXCEEDED = 5,
    DNP3_FILE_ERROR_WRONG_HANDLE = 6,
    DNP3_FILE_ERROR_TOO_MANY_REQUESTS = 7,
    DNP3_FILE_ERROR_IIN_ERROR = 8,
    DNP3_FILE_ERROR_BAD_RESPONSE = 9,
    DNP3_FILE_ERROR_RESPONSE_TIMEOUT = 10,
    DNP3_FILE_ERROR_WRITE_ERROR = 11,
    DNP3_FILE_ERROR_NO_CONNECTION = 12,
    DNP3_FILE_ERROR_SHUTDOWN = 13,
    DNP3_FILE_ERROR_ASSOCIATION_REMOVED = 14,
    DNP3_FILE_ERROR_BAD_ENCODING = 15,
    DNP3_FILE_ERROR_UNSUPPORTED_RESPONSE = 16,
    DNP3_FILE_ERROR_UNSUPPORTED_OR_BAD_RESPONSE = 17,
} dnp3_file_error_t;
 
static const char* dnp3_file_error_to_string(dnp3_file_error_t value)
{
    switch (value)
    {
        case DNP3_FILE_ERROR_OK: return "ok";
        case DNP3_FILE_ERROR_BAD_STATUS: return "bad_status";
        case DNP3_FILE_ERROR_NO_PERMISSION: return "no_permission";
        case DNP3_FILE_ERROR_BAD_BLOCK_NUM: return "bad_block_num";
        case DNP3_FILE_ERROR_ABORT_BY_USER: return "abort_by_user";
        case DNP3_FILE_ERROR_MAX_LENGTH_EXCEEDED: return "max_length_exceeded";
        case DNP3_FILE_ERROR_WRONG_HANDLE: return "wrong_handle";
        case DNP3_FILE_ERROR_TOO_MANY_REQUESTS: return "too_many_requests";
        case DNP3_FILE_ERROR_IIN_ERROR: return "iin_error";
        case DNP3_FILE_ERROR_BAD_RESPONSE: return "bad_response";
        case DNP3_FILE_ERROR_RESPONSE_TIMEOUT: return "response_timeout";
        case DNP3_FILE_ERROR_WRITE_ERROR: return "write_error";
        case DNP3_FILE_ERROR_NO_CONNECTION: return "no_connection";
        case DNP3_FILE_ERROR_SHUTDOWN: return "shutdown";
        case DNP3_FILE_ERROR_ASSOCIATION_REMOVED: return "association_removed";
        case DNP3_FILE_ERROR_BAD_ENCODING: return "bad_encoding";
        case DNP3_FILE_ERROR_UNSUPPORTED_RESPONSE: return "unsupported_response";
        case DNP3_FILE_ERROR_UNSUPPORTED_OR_BAD_RESPONSE: return "unsupported_or_bad_response";
        default: return "unknown file_error value";
    }
}
 
 
typedef struct dnp3_file_info_t dnp3_file_info_t;
 
typedef struct dnp3_file_info_t
{
    const char* file_name;
    dnp3_file_type_t file_type;
    uint32_t size;
    uint64_t time_created;
    dnp3_permissions_t permissions;
} dnp3_file_info_t;
 
 
typedef struct dnp3_file_open_callback_t
{
    
    void (*on_complete)(dnp3_open_file_t, void*);
    
    void (*on_failure)(dnp3_file_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_file_open_callback_t;
 
typedef struct dnp3_file_operation_callback_t
{
    
    void (*on_complete)(dnp3_nothing_t, void*);
    
    void (*on_failure)(dnp3_file_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_file_operation_callback_t;
 
typedef struct dnp3_file_auth_callback_t
{
    
    void (*on_complete)(uint32_t, void*);
    
    void (*on_failure)(dnp3_file_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_file_auth_callback_t;
 
typedef enum dnp3_file_mode_t
{
    DNP3_FILE_MODE_READ = 0,
    DNP3_FILE_MODE_WRITE = 1,
    DNP3_FILE_MODE_APPEND = 2,
} dnp3_file_mode_t;
 
static const char* dnp3_file_mode_to_string(dnp3_file_mode_t value)
{
    switch (value)
    {
        case DNP3_FILE_MODE_READ: return "read";
        case DNP3_FILE_MODE_WRITE: return "write";
        case DNP3_FILE_MODE_APPEND: return "append";
        default: return "unknown file_mode value";
    }
}
 
typedef enum dnp3_udp_socket_mode_t
{
    DNP3_UDP_SOCKET_MODE_ONE_TO_ONE = 0,
    DNP3_UDP_SOCKET_MODE_ONE_TO_MANY = 1,
} dnp3_udp_socket_mode_t;
 
static const char* dnp3_udp_socket_mode_to_string(dnp3_udp_socket_mode_t value)
{
    switch (value)
    {
        case DNP3_UDP_SOCKET_MODE_ONE_TO_ONE: return "one_to_one";
        case DNP3_UDP_SOCKET_MODE_ONE_TO_MANY: return "one_to_many";
        default: return "unknown udp_socket_mode value";
    }
}
 
typedef enum dnp3_link_read_mode_t
{
    DNP3_LINK_READ_MODE_STREAM = 0,
    DNP3_LINK_READ_MODE_DATAGRAM = 1,
} dnp3_link_read_mode_t;
 
static const char* dnp3_link_read_mode_to_string(dnp3_link_read_mode_t value)
{
    switch (value)
    {
        case DNP3_LINK_READ_MODE_STREAM: return "stream";
        case DNP3_LINK_READ_MODE_DATAGRAM: return "datagram";
        default: return "unknown link_read_mode value";
    }
}
 
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;
 
dnp3_param_error_t dnp3_configure_logging(dnp3_logging_config_t config, dnp3_logger_t logger);
 
 
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;
 
static dnp3_header_info_t dnp3_header_info_init(dnp3_variation_t variation, dnp3_qualifier_code_t qualifier, bool is_event, bool has_flags)
{
    dnp3_header_info_t _return_value = {
        variation,
        qualifier,
        is_event,
        has_flags
    };
    return _return_value;
}
 
 
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_frozen_analog_input)(dnp3_header_info_t, dnp3_frozen_analog_input_iterator_t*, void*);
    
    void (*handle_analog_output_status)(dnp3_header_info_t, dnp3_analog_output_status_iterator_t*, void*);
    
    void (*handle_binary_output_command_event)(dnp3_header_info_t, dnp3_binary_output_command_event_iterator_t*, void*);
    
    void (*handle_analog_output_command_event)(dnp3_header_info_t, dnp3_analog_output_command_event_iterator_t*, void*);
    
    void (*handle_unsigned_integer)(dnp3_header_info_t, dnp3_unsigned_integer_iterator_t*, void*);
    
    void (*handle_analog_input_dead_band)(dnp3_header_info_t, dnp3_analog_input_dead_band_iterator_t*, void*);
    
    void (*handle_octet_string)(dnp3_header_info_t, dnp3_octet_string_iterator_t*, void*);
    
    void (*handle_abs_time)(dnp3_header_info_t, dnp3_timestamp_t, void*);
    
    void (*handle_string_attr)(dnp3_header_info_t, dnp3_string_attr_t, uint8_t, uint8_t, const char*, void*);
    
    void (*handle_variation_list_attr)(dnp3_header_info_t, dnp3_variation_list_attr_t, uint8_t, uint8_t, dnp3_attr_item_iter_t*, void*);
    
    void (*handle_uint_attr)(dnp3_header_info_t, dnp3_uint_attr_t, uint8_t, uint8_t, uint32_t, void*);
    
    void (*handle_bool_attr)(dnp3_header_info_t, dnp3_bool_attr_t, uint8_t, uint8_t, bool, void*);
    
    void (*handle_int_attr)(dnp3_header_info_t, dnp3_int_attr_t, uint8_t, uint8_t, int32_t, void*);
    
    void (*handle_time_attr)(dnp3_header_info_t, dnp3_time_attr_t, uint8_t, uint8_t, uint64_t, void*);
    
    void (*handle_float_attr)(dnp3_header_info_t, dnp3_float_attr_t, uint8_t, uint8_t, double, void*);
    
    void (*handle_octet_string_attr)(dnp3_header_info_t, dnp3_octet_string_attr_t, uint8_t, uint8_t, dnp3_byte_iterator_t*, void*);
    
    void (*handle_bit_string_attr)(dnp3_header_info_t, dnp3_bit_string_attr_t, uint8_t, uint8_t, dnp3_byte_iterator_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_read_handler_t;
 
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 struct dnp3_master_channel_t dnp3_master_channel_t;
 
typedef struct dnp3_write_dead_band_request_t dnp3_write_dead_band_request_t;
 
dnp3_write_dead_band_request_t* dnp3_write_dead_band_request_create();
 
void dnp3_write_dead_band_request_destroy(dnp3_write_dead_band_request_t* instance);
 
void dnp3_write_dead_band_request_add_g34v1_u8(dnp3_write_dead_band_request_t* instance, uint8_t index, uint16_t dead_band);
 
void dnp3_write_dead_band_request_add_g34v2_u8(dnp3_write_dead_band_request_t* instance, uint8_t index, uint32_t dead_band);
 
void dnp3_write_dead_band_request_add_g34v3_u8(dnp3_write_dead_band_request_t* instance, uint8_t index, float dead_band);
 
void dnp3_write_dead_band_request_add_g34v1_u16(dnp3_write_dead_band_request_t* instance, uint16_t index, uint16_t dead_band);
 
void dnp3_write_dead_band_request_add_g34v2_u16(dnp3_write_dead_band_request_t* instance, uint16_t index, uint32_t dead_band);
 
void dnp3_write_dead_band_request_add_g34v3_u16(dnp3_write_dead_band_request_t* instance, uint16_t index, float dead_band);
 
void dnp3_write_dead_band_request_finish_header(dnp3_write_dead_band_request_t* instance);
 
 
typedef enum dnp3_empty_response_error_t
{
    DNP3_EMPTY_RESPONSE_ERROR_OK = 0,
    DNP3_EMPTY_RESPONSE_ERROR_REJECTED_BY_IIN2 = 1,
    DNP3_EMPTY_RESPONSE_ERROR_TOO_MANY_REQUESTS = 2,
    DNP3_EMPTY_RESPONSE_ERROR_IIN_ERROR = 3,
    DNP3_EMPTY_RESPONSE_ERROR_BAD_RESPONSE = 4,
    DNP3_EMPTY_RESPONSE_ERROR_RESPONSE_TIMEOUT = 5,
    DNP3_EMPTY_RESPONSE_ERROR_WRITE_ERROR = 6,
    DNP3_EMPTY_RESPONSE_ERROR_NO_CONNECTION = 7,
    DNP3_EMPTY_RESPONSE_ERROR_SHUTDOWN = 8,
    DNP3_EMPTY_RESPONSE_ERROR_ASSOCIATION_REMOVED = 9,
    DNP3_EMPTY_RESPONSE_ERROR_BAD_ENCODING = 10,
    DNP3_EMPTY_RESPONSE_ERROR_UNSUPPORTED_RESPONSE = 11,
    DNP3_EMPTY_RESPONSE_ERROR_UNSUPPORTED_OR_BAD_RESPONSE = 12,
} dnp3_empty_response_error_t;
 
static const char* dnp3_empty_response_error_to_string(dnp3_empty_response_error_t value)
{
    switch (value)
    {
        case DNP3_EMPTY_RESPONSE_ERROR_OK: return "ok";
        case DNP3_EMPTY_RESPONSE_ERROR_REJECTED_BY_IIN2: return "rejected_by_iin2";
        case DNP3_EMPTY_RESPONSE_ERROR_TOO_MANY_REQUESTS: return "too_many_requests";
        case DNP3_EMPTY_RESPONSE_ERROR_IIN_ERROR: return "iin_error";
        case DNP3_EMPTY_RESPONSE_ERROR_BAD_RESPONSE: return "bad_response";
        case DNP3_EMPTY_RESPONSE_ERROR_RESPONSE_TIMEOUT: return "response_timeout";
        case DNP3_EMPTY_RESPONSE_ERROR_WRITE_ERROR: return "write_error";
        case DNP3_EMPTY_RESPONSE_ERROR_NO_CONNECTION: return "no_connection";
        case DNP3_EMPTY_RESPONSE_ERROR_SHUTDOWN: return "shutdown";
        case DNP3_EMPTY_RESPONSE_ERROR_ASSOCIATION_REMOVED: return "association_removed";
        case DNP3_EMPTY_RESPONSE_ERROR_BAD_ENCODING: return "bad_encoding";
        case DNP3_EMPTY_RESPONSE_ERROR_UNSUPPORTED_RESPONSE: return "unsupported_response";
        case DNP3_EMPTY_RESPONSE_ERROR_UNSUPPORTED_OR_BAD_RESPONSE: return "unsupported_or_bad_response";
        default: return "unknown empty_response_error value";
    }
}
 
 
typedef struct dnp3_empty_response_callback_t
{
    
    void (*on_complete)(dnp3_nothing_t, void*);
    
    void (*on_failure)(dnp3_empty_response_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_empty_response_callback_t;
 
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_tcp_2(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_connect_options_t* connect_options, 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);
 
dnp3_param_error_t dnp3_master_channel_create_udp(dnp3_runtime_t* runtime, dnp3_master_channel_config_t config, const char* local_endpoint, dnp3_link_read_mode_t link_read_mode, uint64_t retry_delay, 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_create_tls_2(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_connect_options_t* connect_options, 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_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_DIRECT_WRITE_ABS_TIME = 3,
} 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";
        case DNP3_AUTO_TIME_SYNC_DIRECT_WRITE_ABS_TIME: return "direct_write_abs_time";
        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;
 
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_WRITE_DEAD_BANDS = 10,
    DNP3_TASK_TYPE_GENERIC_EMPTY_RESPONSE = 11,
    DNP3_TASK_TYPE_FILE_READ = 12,
    DNP3_TASK_TYPE_GET_FILE_INFO = 13,
    DNP3_TASK_TYPE_FILE_AUTH = 14,
    DNP3_TASK_TYPE_FILE_OPEN = 15,
    DNP3_TASK_TYPE_FILE_WRITE_BLOCK = 16,
    DNP3_TASK_TYPE_FILE_CLOSE = 17,
} 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";
        case DNP3_TASK_TYPE_WRITE_DEAD_BANDS: return "write_dead_bands";
        case DNP3_TASK_TYPE_GENERIC_EMPTY_RESPONSE: return "generic_empty_response";
        case DNP3_TASK_TYPE_FILE_READ: return "file_read";
        case DNP3_TASK_TYPE_GET_FILE_INFO: return "get_file_info";
        case DNP3_TASK_TYPE_FILE_AUTH: return "file_auth";
        case DNP3_TASK_TYPE_FILE_OPEN: return "file_open";
        case DNP3_TASK_TYPE_FILE_WRITE_BLOCK: return "file_write_block";
        case DNP3_TASK_TYPE_FILE_CLOSE: return "file_close";
        default: return "unknown task_type value";
    }
}
 
typedef enum dnp3_task_error_t
{
    DNP3_TASK_ERROR_TOO_MANY_REQUESTS = 0,
    DNP3_TASK_ERROR_IIN_ERROR = 1,
    DNP3_TASK_ERROR_BAD_RESPONSE = 2,
    DNP3_TASK_ERROR_RESPONSE_TIMEOUT = 3,
    DNP3_TASK_ERROR_WRITE_ERROR = 4,
    DNP3_TASK_ERROR_NO_CONNECTION = 5,
    DNP3_TASK_ERROR_SHUTDOWN = 6,
    DNP3_TASK_ERROR_ASSOCIATION_REMOVED = 7,
    DNP3_TASK_ERROR_BAD_ENCODING = 8,
    DNP3_TASK_ERROR_UNSUPPORTED_RESPONSE = 9,
    DNP3_TASK_ERROR_UNSUPPORTED_OR_BAD_RESPONSE = 10,
    DNP3_TASK_ERROR_SYSTEM_TIME_NOT_AVAILABLE = 11,
} 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_IIN_ERROR: return "iin_error";
        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";
        case DNP3_TASK_ERROR_BAD_ENCODING: return "bad_encoding";
        case DNP3_TASK_ERROR_UNSUPPORTED_RESPONSE: return "unsupported_response";
        case DNP3_TASK_ERROR_UNSUPPORTED_OR_BAD_RESPONSE: return "unsupported_or_bad_response";
        case DNP3_TASK_ERROR_SYSTEM_TIME_NOT_AVAILABLE: return "system_time_not_available";
        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;
 
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_specific_attribute(dnp3_request_t* instance, uint8_t variation, uint8_t set);
 
void dnp3_request_add_string_attribute(dnp3_request_t* instance, uint8_t variation, uint8_t set, const char* value);
 
void dnp3_request_add_uint_attribute(dnp3_request_t* instance, uint8_t variation, uint8_t set, uint32_t value);
 
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);
 
void dnp3_request_add_time_and_interval(dnp3_request_t* instance, uint64_t time, uint32_t interval_ms);
 
 
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_add_udp_association(dnp3_master_channel_t* instance, uint16_t address, const char* destination, 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_IIN_ERROR = 2,
    DNP3_READ_ERROR_BAD_RESPONSE = 3,
    DNP3_READ_ERROR_RESPONSE_TIMEOUT = 4,
    DNP3_READ_ERROR_WRITE_ERROR = 5,
    DNP3_READ_ERROR_NO_CONNECTION = 6,
    DNP3_READ_ERROR_SHUTDOWN = 7,
    DNP3_READ_ERROR_ASSOCIATION_REMOVED = 8,
    DNP3_READ_ERROR_BAD_ENCODING = 9,
    DNP3_READ_ERROR_UNSUPPORTED_RESPONSE = 10,
    DNP3_READ_ERROR_UNSUPPORTED_OR_BAD_RESPONSE = 11,
} 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_IIN_ERROR: return "iin_error";
        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";
        case DNP3_READ_ERROR_BAD_ENCODING: return "bad_encoding";
        case DNP3_READ_ERROR_UNSUPPORTED_RESPONSE: return "unsupported_response";
        case DNP3_READ_ERROR_UNSUPPORTED_OR_BAD_RESPONSE: return "unsupported_or_bad_response";
        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;
 
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_write_dead_bands(dnp3_master_channel_t* instance, dnp3_association_id_t association, dnp3_write_dead_band_request_t* request, dnp3_empty_response_callback_t callback);
 
dnp3_param_error_t dnp3_master_channel_send_and_expect_empty_response(dnp3_master_channel_t* instance, dnp3_association_id_t association, dnp3_function_code_t function, dnp3_request_t* headers, dnp3_empty_response_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_IIN_ERROR = 4,
    DNP3_COMMAND_ERROR_BAD_RESPONSE = 5,
    DNP3_COMMAND_ERROR_RESPONSE_TIMEOUT = 6,
    DNP3_COMMAND_ERROR_WRITE_ERROR = 7,
    DNP3_COMMAND_ERROR_NO_CONNECTION = 8,
    DNP3_COMMAND_ERROR_SHUTDOWN = 9,
    DNP3_COMMAND_ERROR_ASSOCIATION_REMOVED = 10,
    DNP3_COMMAND_ERROR_BAD_ENCODING = 11,
    DNP3_COMMAND_ERROR_UNSUPPORTED_RESPONSE = 12,
    DNP3_COMMAND_ERROR_UNSUPPORTED_OR_BAD_RESPONSE = 13,
} 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_IIN_ERROR: return "iin_error";
        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";
        case DNP3_COMMAND_ERROR_BAD_ENCODING: return "bad_encoding";
        case DNP3_COMMAND_ERROR_UNSUPPORTED_RESPONSE: return "unsupported_response";
        case DNP3_COMMAND_ERROR_UNSUPPORTED_OR_BAD_RESPONSE: return "unsupported_or_bad_response";
        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;
 
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);
 
dnp3_param_error_t dnp3_master_channel_operate_no_ack(dnp3_master_channel_t* instance, dnp3_association_id_t association, 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_DIRECT_WRITE_ABS_TIME = 2,
} 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";
        case DNP3_TIME_SYNC_MODE_DIRECT_WRITE_ABS_TIME: return "direct_write_abs_time";
        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_TOO_MANY_REQUESTS = 7,
    DNP3_TIME_SYNC_ERROR_IIN_ERROR = 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_BAD_ENCODING = 15,
    DNP3_TIME_SYNC_ERROR_UNSUPPORTED_RESPONSE = 16,
    DNP3_TIME_SYNC_ERROR_UNSUPPORTED_OR_BAD_RESPONSE = 17,
} 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_TOO_MANY_REQUESTS: return "too_many_requests";
        case DNP3_TIME_SYNC_ERROR_IIN_ERROR: return "iin_error";
        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";
        case DNP3_TIME_SYNC_ERROR_BAD_ENCODING: return "bad_encoding";
        case DNP3_TIME_SYNC_ERROR_UNSUPPORTED_RESPONSE: return "unsupported_response";
        case DNP3_TIME_SYNC_ERROR_UNSUPPORTED_OR_BAD_RESPONSE: return "unsupported_or_bad_response";
        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;
 
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_IIN_ERROR = 2,
    DNP3_RESTART_ERROR_BAD_RESPONSE = 3,
    DNP3_RESTART_ERROR_RESPONSE_TIMEOUT = 4,
    DNP3_RESTART_ERROR_WRITE_ERROR = 5,
    DNP3_RESTART_ERROR_NO_CONNECTION = 6,
    DNP3_RESTART_ERROR_SHUTDOWN = 7,
    DNP3_RESTART_ERROR_ASSOCIATION_REMOVED = 8,
    DNP3_RESTART_ERROR_BAD_ENCODING = 9,
    DNP3_RESTART_ERROR_UNSUPPORTED_RESPONSE = 10,
    DNP3_RESTART_ERROR_UNSUPPORTED_OR_BAD_RESPONSE = 11,
} 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_IIN_ERROR: return "iin_error";
        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";
        case DNP3_RESTART_ERROR_BAD_ENCODING: return "bad_encoding";
        case DNP3_RESTART_ERROR_UNSUPPORTED_RESPONSE: return "unsupported_response";
        case DNP3_RESTART_ERROR_UNSUPPORTED_OR_BAD_RESPONSE: return "unsupported_or_bad_response";
        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;
 
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 struct dnp3_file_info_callback_t
{
    
    void (*on_complete)(dnp3_file_info_t, void*);
    
    void (*on_failure)(dnp3_file_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_file_info_callback_t;
 
typedef struct dnp3_file_reader_t
{
    
    bool (*opened)(uint32_t, void*);
    
    bool (*block_received)(uint32_t, dnp3_byte_iterator_t*, void*);
    
    void (*aborted)(dnp3_file_error_t, void*);
    
    void (*completed)(void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_file_reader_t;
 
typedef struct dnp3_file_read_config_t dnp3_file_read_config_t;
 
typedef struct dnp3_file_read_config_t
{
    uint16_t max_block_size;
    uint32_t max_file_size;
} dnp3_file_read_config_t;
 
static dnp3_file_read_config_t dnp3_file_read_config_defaults()
{
    dnp3_file_read_config_t _return_value = {
        65535,
        4294967295
    };
    return _return_value;
}
 
 
typedef struct dnp3_dir_read_config_t dnp3_dir_read_config_t;
 
typedef struct dnp3_dir_read_config_t
{
    uint16_t max_block_size;
    uint32_t max_file_size;
} dnp3_dir_read_config_t;
 
static dnp3_dir_read_config_t dnp3_dir_read_config_defaults()
{
    dnp3_dir_read_config_t _return_value = {
        65535,
        2048
    };
    return _return_value;
}
 
 
dnp3_param_error_t dnp3_master_channel_read_file(dnp3_master_channel_t* instance, dnp3_association_id_t association, const char* remote_file_path, dnp3_file_read_config_t config, dnp3_file_reader_t reader);
 
dnp3_param_error_t dnp3_master_channel_read_file_with_auth(dnp3_master_channel_t* instance, dnp3_association_id_t association, const char* remote_file_path, dnp3_file_read_config_t config, dnp3_file_reader_t reader, const char* user_name, const char* password);
 
dnp3_param_error_t dnp3_master_channel_get_file_auth_key(dnp3_master_channel_t* instance, dnp3_association_id_t association, const char* username, const char* password, dnp3_file_auth_callback_t callback);
 
dnp3_param_error_t dnp3_master_channel_open_file(dnp3_master_channel_t* instance, dnp3_association_id_t association, const char* file_name, uint32_t auth_key, dnp3_permissions_t permissions, uint32_t file_size, dnp3_file_mode_t file_mode, uint16_t max_block_size, dnp3_file_open_callback_t callback);
 
dnp3_param_error_t dnp3_master_channel_write_file_block(dnp3_master_channel_t* instance, dnp3_association_id_t association, uint32_t handle, uint32_t block_number, bool final_block, dnp3_byte_collection_t* block_data, dnp3_file_operation_callback_t callback);
 
dnp3_param_error_t dnp3_master_channel_close_file(dnp3_master_channel_t* instance, dnp3_association_id_t association, uint32_t handle, dnp3_file_operation_callback_t callback);
 
dnp3_param_error_t dnp3_master_channel_get_file_info(dnp3_master_channel_t* instance, dnp3_association_id_t association, const char* file_name, dnp3_file_info_callback_t callback);
 
typedef struct dnp3_file_info_iterator_t dnp3_file_info_iterator_t;
 
dnp3_file_info_t* dnp3_file_info_iterator_next(dnp3_file_info_iterator_t* iter);
 
 
typedef struct dnp3_read_directory_callback_t
{
    
    void (*on_complete)(dnp3_file_info_iterator_t*, void*);
    
    void (*on_failure)(dnp3_file_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_read_directory_callback_t;
 
dnp3_param_error_t dnp3_master_channel_read_directory(dnp3_master_channel_t* instance, dnp3_association_id_t association, const char* dir_path, dnp3_dir_read_config_t config, dnp3_read_directory_callback_t callback);
 
dnp3_param_error_t dnp3_master_channel_read_directory_with_auth(dnp3_master_channel_t* instance, dnp3_association_id_t association, const char* dir_path, dnp3_dir_read_config_t config, const char* user_name, const char* password, dnp3_read_directory_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_IIN_ERROR = 3,
    DNP3_LINK_STATUS_ERROR_BAD_RESPONSE = 4,
    DNP3_LINK_STATUS_ERROR_RESPONSE_TIMEOUT = 5,
    DNP3_LINK_STATUS_ERROR_WRITE_ERROR = 6,
    DNP3_LINK_STATUS_ERROR_NO_CONNECTION = 7,
    DNP3_LINK_STATUS_ERROR_SHUTDOWN = 8,
    DNP3_LINK_STATUS_ERROR_ASSOCIATION_REMOVED = 9,
    DNP3_LINK_STATUS_ERROR_BAD_ENCODING = 10,
    DNP3_LINK_STATUS_ERROR_UNSUPPORTED_RESPONSE = 11,
    DNP3_LINK_STATUS_ERROR_UNSUPPORTED_OR_BAD_RESPONSE = 12,
} 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_IIN_ERROR: return "iin_error";
        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";
        case DNP3_LINK_STATUS_ERROR_BAD_ENCODING: return "bad_encoding";
        case DNP3_LINK_STATUS_ERROR_UNSUPPORTED_RESPONSE: return "unsupported_response";
        case DNP3_LINK_STATUS_ERROR_UNSUPPORTED_OR_BAD_RESPONSE: return "unsupported_or_bad_response";
        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;
 
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_accept_handler_t dnp3_accept_handler_t;
 
dnp3_param_error_t dnp3_accept_handler_accept(dnp3_accept_handler_t* instance, dnp3_link_error_mode_t error_mode, dnp3_master_channel_config_t config);
 
dnp3_param_error_t dnp3_accept_handler_get_link_identity(dnp3_accept_handler_t* instance);
 
 
typedef struct dnp3_identified_link_handler_t dnp3_identified_link_handler_t;
 
dnp3_param_error_t dnp3_identified_link_handler_accept(dnp3_identified_link_handler_t* instance, dnp3_link_error_mode_t error_mode, dnp3_master_channel_config_t config);
 
 
typedef struct dnp3_connection_handler_t
{
    
    void (*accept)(const char*, dnp3_accept_handler_t*, void*);
    
    void (*start)(const char*, dnp3_master_channel_t*, void*);
    
    void (*accept_with_link_id)(const char*, uint16_t, uint16_t, dnp3_identified_link_handler_t*, void*);
    
    void (*start_with_link_id)(const char*, uint16_t, uint16_t, dnp3_master_channel_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_connection_handler_t;
 
typedef struct dnp3_master_server_t dnp3_master_server_t;
 
typedef struct dnp3_link_id_config_t dnp3_link_id_config_t;
 
typedef struct dnp3_link_id_config_t
{
    uint16_t max_tasks;
    uint64_t timeout;
    dnp3_phys_decode_level_t decode_level;
} dnp3_link_id_config_t;
 
static dnp3_link_id_config_t dnp3_link_id_config_init()
{
    dnp3_link_id_config_t _return_value = {
        16,
        5000,
        DNP3_PHYS_DECODE_LEVEL_NOTHING
    };
    return _return_value;
}
 
 
void dnp3_master_server_destroy(dnp3_master_server_t* instance);
 
dnp3_param_error_t dnp3_create_master_tcp_server(dnp3_runtime_t* runtime, const char* local_addr, dnp3_link_id_config_t link_id_config, dnp3_connection_handler_t connection_handler, dnp3_master_server_t** out);
 
 
typedef struct dnp3_database_t dnp3_database_t;
 
typedef enum dnp3_update_result_t
{
    DNP3_UPDATE_RESULT_NO_POINT = 0,
    DNP3_UPDATE_RESULT_NO_EVENT = 1,
    DNP3_UPDATE_RESULT_CREATED = 2,
    DNP3_UPDATE_RESULT_OVERFLOW = 3,
} dnp3_update_result_t;
 
static const char* dnp3_update_result_to_string(dnp3_update_result_t value)
{
    switch (value)
    {
        case DNP3_UPDATE_RESULT_NO_POINT: return "no_point";
        case DNP3_UPDATE_RESULT_NO_EVENT: return "no_event";
        case DNP3_UPDATE_RESULT_CREATED: return "created";
        case DNP3_UPDATE_RESULT_OVERFLOW: return "overflow";
        default: return "unknown update_result value";
    }
}
 
typedef struct dnp3_update_info_t dnp3_update_info_t;
 
typedef struct dnp3_update_info_t
{
    dnp3_update_result_t result;
    uint64_t created;
    uint64_t discarded;
} dnp3_update_info_t;
 
 
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_update_flags_type_t
{
    DNP3_UPDATE_FLAGS_TYPE_BINARY_INPUT = 0,
    DNP3_UPDATE_FLAGS_TYPE_DOUBLE_BIT_BINARY_INPUT = 1,
    DNP3_UPDATE_FLAGS_TYPE_BINARY_OUTPUT_STATUS = 2,
    DNP3_UPDATE_FLAGS_TYPE_COUNTER = 3,
    DNP3_UPDATE_FLAGS_TYPE_FROZEN_COUNTER = 4,
    DNP3_UPDATE_FLAGS_TYPE_ANALOG_INPUT = 5,
    DNP3_UPDATE_FLAGS_TYPE_ANALOG_OUTPUT_STATUS = 6,
} dnp3_update_flags_type_t;
 
static const char* dnp3_update_flags_type_to_string(dnp3_update_flags_type_t value)
{
    switch (value)
    {
        case DNP3_UPDATE_FLAGS_TYPE_BINARY_INPUT: return "binary_input";
        case DNP3_UPDATE_FLAGS_TYPE_DOUBLE_BIT_BINARY_INPUT: return "double_bit_binary_input";
        case DNP3_UPDATE_FLAGS_TYPE_BINARY_OUTPUT_STATUS: return "binary_output_status";
        case DNP3_UPDATE_FLAGS_TYPE_COUNTER: return "counter";
        case DNP3_UPDATE_FLAGS_TYPE_FROZEN_COUNTER: return "frozen_counter";
        case DNP3_UPDATE_FLAGS_TYPE_ANALOG_INPUT: return "analog_input";
        case DNP3_UPDATE_FLAGS_TYPE_ANALOG_OUTPUT_STATUS: return "analog_output_status";
        default: return "unknown update_flags_type value";
    }
}
 
dnp3_update_info_t dnp3_database_update_flags(dnp3_database_t* instance, uint16_t index, dnp3_update_flags_type_t flags_type, dnp3_flags_t flags, dnp3_timestamp_t time, dnp3_update_options_t options);
 
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_create(dnp3_static_binary_input_variation_t static_variation, dnp3_event_binary_input_variation_t event_variation)
{
    dnp3_binary_input_config_t _return_value = {
        static_variation,
        event_variation
    };
    return _return_value;
}
 
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_update_info_t dnp3_database_update_binary_input_2(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_create(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 _return_value = {
        static_variation,
        event_variation
    };
    return _return_value;
}
 
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_update_info_t dnp3_database_update_double_bit_binary_input_2(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_create(dnp3_static_binary_output_status_variation_t static_variation, dnp3_event_binary_output_status_variation_t event_variation)
{
    dnp3_binary_output_status_config_t _return_value = {
        static_variation,
        event_variation
    };
    return _return_value;
}
 
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_VAR2,
        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_update_info_t dnp3_database_update_binary_output_status_2(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_create(dnp3_static_counter_variation_t static_variation, dnp3_event_counter_variation_t event_variation, uint32_t deadband)
{
    dnp3_counter_config_t _return_value = {
        static_variation,
        event_variation,
        deadband
    };
    return _return_value;
}
 
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_update_info_t dnp3_database_update_counter_2(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_create(dnp3_static_frozen_counter_variation_t static_variation, dnp3_event_frozen_counter_variation_t event_variation, uint32_t deadband)
{
    dnp3_frozen_counter_config_t _return_value = {
        static_variation,
        event_variation,
        deadband
    };
    return _return_value;
}
 
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_update_info_t dnp3_database_update_frozen_counter_2(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_create(dnp3_static_analog_input_variation_t static_variation, dnp3_event_analog_input_variation_t event_variation, double deadband)
{
    dnp3_analog_input_config_t _return_value = {
        static_variation,
        event_variation,
        deadband
    };
    return _return_value;
}
 
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_update_info_t dnp3_database_update_analog_input_2(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_create(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 _return_value = {
        static_variation,
        event_variation,
        deadband
    };
    return _return_value;
}
 
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_update_info_t dnp3_database_update_analog_output_status_2(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);
 
dnp3_update_info_t dnp3_database_update_octet_string_2(dnp3_database_t* instance, uint16_t index, dnp3_octet_string_value_t* value, dnp3_update_options_t options);
 
typedef enum dnp3_attr_def_error_t
{
    DNP3_ATTR_DEF_ERROR_OK = 0,
    DNP3_ATTR_DEF_ERROR_ALREADY_DEFINED = 1,
    DNP3_ATTR_DEF_ERROR_RESERVED_VARIATION = 2,
    DNP3_ATTR_DEF_ERROR_BAD_TYPE = 3,
    DNP3_ATTR_DEF_ERROR_NOT_WRITABLE = 4,
    DNP3_ATTR_DEF_ERROR_BAD_VALUE = 5,
} dnp3_attr_def_error_t;
 
static const char* dnp3_attr_def_error_to_string(dnp3_attr_def_error_t value)
{
    switch (value)
    {
        case DNP3_ATTR_DEF_ERROR_OK: return "ok";
        case DNP3_ATTR_DEF_ERROR_ALREADY_DEFINED: return "already_defined";
        case DNP3_ATTR_DEF_ERROR_RESERVED_VARIATION: return "reserved_variation";
        case DNP3_ATTR_DEF_ERROR_BAD_TYPE: return "bad_type";
        case DNP3_ATTR_DEF_ERROR_NOT_WRITABLE: return "not_writable";
        case DNP3_ATTR_DEF_ERROR_BAD_VALUE: return "bad_value";
        default: return "unknown attr_def_error value";
    }
}
 
dnp3_attr_def_error_t dnp3_database_define_string_attr(dnp3_database_t* instance, uint8_t set, bool writable, uint8_t variation, const char* value);
 
dnp3_attr_def_error_t dnp3_database_define_float_attr(dnp3_database_t* instance, uint8_t set, bool writable, uint8_t variation, float value);
 
dnp3_attr_def_error_t dnp3_database_define_double_attr(dnp3_database_t* instance, uint8_t set, bool writable, uint8_t variation, double value);
 
dnp3_attr_def_error_t dnp3_database_define_uint_attr(dnp3_database_t* instance, uint8_t set, bool writable, uint8_t variation, uint32_t value);
 
dnp3_attr_def_error_t dnp3_database_define_int_attr(dnp3_database_t* instance, uint8_t set, bool writable, uint8_t variation, int32_t value);
 
dnp3_attr_def_error_t dnp3_database_define_time_attr(dnp3_database_t* instance, uint8_t set, bool writable, uint8_t variation, uint64_t value);
 
dnp3_attr_def_error_t dnp3_database_define_bool_attr(dnp3_database_t* instance, uint8_t set, bool writable, uint8_t variation, bool value);
 
dnp3_class_count_t dnp3_database_discard_unselected_events(dnp3_database_t* instance, dnp3_event_classes_t classes);
 
 
typedef struct dnp3_database_transaction_t
{
    
    void (*execute)(dnp3_database_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_database_transaction_t;
 
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;
    bool respond_to_any_master;
} dnp3_outstation_features_t;
 
static dnp3_outstation_features_t dnp3_outstation_features_init()
{
    dnp3_outstation_features_t _return_value = {
        false,
        true,
        true,
        false
    };
    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_point_type_t
{
    DNP3_POINT_TYPE_BINARY_INPUT = 0,
    DNP3_POINT_TYPE_DOUBLE_BIT_BINARY_INPUT = 1,
    DNP3_POINT_TYPE_BINARY_OUTPUT_STATUS = 2,
    DNP3_POINT_TYPE_COUNTER = 3,
    DNP3_POINT_TYPE_FROZEN_COUNTER = 4,
    DNP3_POINT_TYPE_ANALOG_INPUT = 5,
    DNP3_POINT_TYPE_ANALOG_OUTPUT_STATUS = 6,
    DNP3_POINT_TYPE_OCTET_STRING = 7,
} dnp3_point_type_t;
 
static const char* dnp3_point_type_to_string(dnp3_point_type_t value)
{
    switch (value)
    {
        case DNP3_POINT_TYPE_BINARY_INPUT: return "binary_input";
        case DNP3_POINT_TYPE_DOUBLE_BIT_BINARY_INPUT: return "double_bit_binary_input";
        case DNP3_POINT_TYPE_BINARY_OUTPUT_STATUS: return "binary_output_status";
        case DNP3_POINT_TYPE_COUNTER: return "counter";
        case DNP3_POINT_TYPE_FROZEN_COUNTER: return "frozen_counter";
        case DNP3_POINT_TYPE_ANALOG_INPUT: return "analog_input";
        case DNP3_POINT_TYPE_ANALOG_OUTPUT_STATUS: return "analog_output_status";
        case DNP3_POINT_TYPE_OCTET_STRING: return "octet_string";
        default: return "unknown point_type 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_type_count_t dnp3_type_count_t;
 
typedef struct dnp3_type_count_t
{
    uint32_t num_binary_input;
    uint32_t num_double_bit_binary_input;
    uint32_t num_binary_output_status;
    uint32_t num_counter;
    uint32_t num_frozen_counter;
    uint32_t num_analog;
    uint32_t num_analog_output_status;
    uint32_t num_octet_string;
} dnp3_type_count_t;
 
 
typedef struct dnp3_buffer_state_t dnp3_buffer_state_t;
 
typedef struct dnp3_buffer_state_t
{
    dnp3_class_count_t classes;
    dnp3_type_count_t types;
} dnp3_buffer_state_t;
 
 
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_all_at_time)(dnp3_database_handle_t*, uint64_t, uint32_t, void*);
    
    dnp3_freeze_result_t (*freeze_counters_range)(uint16_t, uint16_t, dnp3_freeze_type_t, dnp3_database_handle_t*, void*);
    
    dnp3_freeze_result_t (*freeze_counters_range_at_time)(uint16_t, uint16_t, dnp3_database_handle_t*, uint64_t, uint32_t, void*);
    
    bool (*support_write_analog_dead_bands)(void*);
    
    void (*begin_write_analog_dead_bands)(void*);
    
    void (*write_analog_dead_band)(uint16_t, double, void*);
    
    void (*end_write_analog_dead_bands)(void*);
    
    bool (*support_assign_class)(void*);
    
    void (*begin_assign_class)(void*);
    
    void (*assign_class_all)(dnp3_point_type_t, dnp3_event_class_t, void*);
    
    void (*assign_class_range)(dnp3_point_type_t, uint16_t, uint16_t, dnp3_event_class_t, void*);
    
    void (*end_assign_class)(void*);
    
    bool (*write_string_attr)(uint8_t, uint8_t, dnp3_string_attr_t, const char*, void*);
    
    bool (*write_float_attr)(uint8_t, uint8_t, dnp3_float_attr_t, float, void*);
    
    bool (*write_double_attr)(uint8_t, uint8_t, dnp3_float_attr_t, double, void*);
    
    bool (*write_uint_attr)(uint8_t, uint8_t, dnp3_uint_attr_t, uint32_t, void*);
    
    bool (*write_int_attr)(uint8_t, uint8_t, dnp3_int_attr_t, int32_t, void*);
    
    bool (*write_octet_string_attr)(uint8_t, uint8_t, dnp3_octet_string_attr_t, dnp3_byte_iterator_t*, void*);
    
    bool (*write_bit_string_attr)(uint8_t, uint8_t, dnp3_bit_string_attr_t, dnp3_byte_iterator_t*, void*);
    
    bool (*write_time_attr)(uint8_t, uint8_t, dnp3_time_attr_t, uint64_t, void*);
    
    void (*begin_confirm)(void*);
    
    void (*event_cleared)(uint64_t, void*);
    
    void (*end_confirm)(dnp3_buffer_state_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_outstation_application_t;
 
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;
 
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;
 
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;
 
typedef struct dnp3_connection_info_t dnp3_connection_info_t;
 
dnp3_connection_info_t* dnp3_connection_info_create();
 
dnp3_param_error_t dnp3_connection_info_set_endpoint(dnp3_connection_info_t* instance, const char* endpoint);
 
void dnp3_connection_info_set_timeout(dnp3_connection_info_t* instance, uint64_t timeout_ms);
 
void dnp3_connection_info_clear_timeout(dnp3_connection_info_t* instance);
 
dnp3_param_error_t dnp3_connection_info_set_local_endpoint(dnp3_connection_info_t* instance, const char* local_endpoint);
 
void dnp3_connection_info_clear_local_endpoint(dnp3_connection_info_t* instance);
 
dnp3_param_error_t dnp3_connection_info_set_master_address(dnp3_connection_info_t* instance, uint16_t address);
 
void dnp3_connection_info_destroy(dnp3_connection_info_t* instance);
 
 
typedef struct dnp3_next_endpoint_action_t dnp3_next_endpoint_action_t;
 
dnp3_param_error_t dnp3_next_endpoint_action_connect_to(dnp3_next_endpoint_action_t* instance, dnp3_connection_info_t* info);
 
dnp3_param_error_t dnp3_next_endpoint_action_sleep_for(dnp3_next_endpoint_action_t* instance, uint64_t duration);
 
 
typedef struct dnp3_client_connection_handler_t
{
    
    uint64_t (*disconnected)(const char*, const char*, void*);
    
    void (*connecting)(const char*, const char*, void*);
    
    void (*connect_failed)(const char*, const char*, void*);
    
    void (*connected)(const char*, const char*, void*);
    
    void (*resolution_failed)(const char*, void*);
    
    void (*next)(dnp3_next_endpoint_action_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_client_connection_handler_t;
 
typedef struct dnp3_outstation_t dnp3_outstation_t;
 
dnp3_param_error_t dnp3_outstation_create_tcp_client(dnp3_runtime_t* runtime, dnp3_link_error_mode_t link_error_mode, dnp3_endpoint_list_t* endpoints, dnp3_connect_strategy_t connect_strategy, dnp3_connect_options_t* connect_options, dnp3_outstation_config_t config, dnp3_outstation_application_t application, dnp3_outstation_information_t information, dnp3_control_handler_t control_handler, dnp3_client_state_listener_t listener, dnp3_outstation_t** out);
 
dnp3_param_error_t dnp3_outstation_create_tcp_client_with_handler(dnp3_runtime_t* runtime, dnp3_link_error_mode_t link_error_mode, const char* span_name, dnp3_outstation_config_t config, dnp3_outstation_application_t application, dnp3_outstation_information_t information, dnp3_control_handler_t control_handler, dnp3_client_state_listener_t listener, dnp3_client_connection_handler_t connection_handler, dnp3_outstation_t** out);
 
dnp3_param_error_t dnp3_outstation_create_tls_client(dnp3_runtime_t* runtime, dnp3_link_error_mode_t link_error_mode, dnp3_endpoint_list_t* endpoints, dnp3_connect_strategy_t connect_strategy, dnp3_connect_options_t* connect_options, dnp3_outstation_config_t config, dnp3_outstation_application_t application, dnp3_outstation_information_t information, dnp3_control_handler_t control_handler, dnp3_client_state_listener_t listener, dnp3_tls_client_config_t tls_config, dnp3_outstation_t** out);
 
dnp3_param_error_t dnp3_outstation_create_tls_client_with_handler(dnp3_runtime_t* runtime, dnp3_link_error_mode_t link_error_mode, const char* span_name, dnp3_outstation_config_t config, dnp3_outstation_application_t application, dnp3_outstation_information_t information, dnp3_control_handler_t control_handler, dnp3_client_state_listener_t listener, dnp3_client_connection_handler_t connection_handler, dnp3_tls_client_config_t tls_config, dnp3_outstation_t** out);
 
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);
 
dnp3_param_error_t dnp3_outstation_create_serial_session_2(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_port_state_listener_t port_listener, dnp3_outstation_t** out);
 
typedef struct dnp3_outstation_udp_config_t dnp3_outstation_udp_config_t;
 
typedef struct dnp3_outstation_udp_config_t
{
    const char* local_endpoint;
    const char* remote_endpoint;
    dnp3_udp_socket_mode_t socket_mode;
    dnp3_link_read_mode_t link_read_mode;
    uint64_t retry_delay;
} dnp3_outstation_udp_config_t;
 
static dnp3_outstation_udp_config_t dnp3_outstation_udp_config_init(const char* local_endpoint, const char* remote_endpoint)
{
    dnp3_outstation_udp_config_t _return_value = {
        local_endpoint,
        remote_endpoint,
        DNP3_UDP_SOCKET_MODE_ONE_TO_ONE,
        DNP3_LINK_READ_MODE_DATAGRAM,
        5000
    };
    return _return_value;
}
 
 
dnp3_param_error_t dnp3_outstation_create_udp(dnp3_runtime_t* runtime, dnp3_outstation_udp_config_t udp_config, 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);
 
dnp3_param_error_t dnp3_outstation_enable(dnp3_outstation_t* instance);
 
dnp3_param_error_t dnp3_outstation_disable(dnp3_outstation_t* instance);
 
 
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;
    bool allow_client_name_wildcard;
} 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,
        false
    };
    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