dnp3.h

Go to the documentation of this file.

// This library is provided under the terms of a non-commercial license.
// 
// Please refer to the source repository for details:
// 
// https://github.com/stepfunc/dnp3/blob/master/LICENSE.txt
// 
// Please contact Step Function I/O if you are interested in commercial license:
// 
// info@stepfunc.io
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define DNP3_VERSION_MAJOR 0
#define DNP3_VERSION_MINOR 9
#define DNP3_VERSION_PATCH 0
#define DNP3_VERSION_STRING "0.9.0"
 
#include <stdbool.h>
#include <stdint.h>
 
 
typedef enum dnp3_param_error_t
{
    DNP3_PARAM_ERROR_OK = 0,
    DNP3_PARAM_ERROR_NULL_PARAMETER = 1,
    DNP3_PARAM_ERROR_ASSOCIATION_DOES_NOT_EXIST = 2,
    DNP3_PARAM_ERROR_ASSOCIATION_DUPLICATE_ADDRESS = 3,
    DNP3_PARAM_ERROR_INVALID_SOCKET_ADDRESS = 4,
    DNP3_PARAM_ERROR_INVALID_DNP3_ADDRESS = 5,
    DNP3_PARAM_ERROR_INVALID_BUFFER_SIZE = 6,
    DNP3_PARAM_ERROR_ADDRESS_FILTER_CONFLICT = 7,
    DNP3_PARAM_ERROR_SERVER_ALREADY_STARTED = 8,
    DNP3_PARAM_ERROR_SERVER_BIND_ERROR = 9,
    DNP3_PARAM_ERROR_MASTER_ALREADY_SHUTDOWN = 10,
    DNP3_PARAM_ERROR_RUNTIME_CREATION_FAILURE = 11,
    DNP3_PARAM_ERROR_RUNTIME_DESTROYED = 12,
    DNP3_PARAM_ERROR_RUNTIME_CANNOT_BLOCK_WITHIN_ASYNC = 13,
    DNP3_PARAM_ERROR_LOGGING_ALREADY_CONFIGURED = 14,
    DNP3_PARAM_ERROR_POINT_DOES_NOT_EXIST = 15,
} 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_NULL_PARAMETER: return "NullParameter";
        case DNP3_PARAM_ERROR_ASSOCIATION_DOES_NOT_EXIST: return "AssociationDoesNotExist";
        case DNP3_PARAM_ERROR_ASSOCIATION_DUPLICATE_ADDRESS: return "AssociationDuplicateAddress";
        case DNP3_PARAM_ERROR_INVALID_SOCKET_ADDRESS: return "InvalidSocketAddress";
        case DNP3_PARAM_ERROR_INVALID_DNP3_ADDRESS: return "InvalidDnp3Address";
        case DNP3_PARAM_ERROR_INVALID_BUFFER_SIZE: return "InvalidBufferSize";
        case DNP3_PARAM_ERROR_ADDRESS_FILTER_CONFLICT: return "AddressFilterConflict";
        case DNP3_PARAM_ERROR_SERVER_ALREADY_STARTED: return "ServerAlreadyStarted";
        case DNP3_PARAM_ERROR_SERVER_BIND_ERROR: return "ServerBindError";
        case DNP3_PARAM_ERROR_MASTER_ALREADY_SHUTDOWN: return "MasterAlreadyShutdown";
        case DNP3_PARAM_ERROR_RUNTIME_CREATION_FAILURE: return "RuntimeCreationFailure";
        case DNP3_PARAM_ERROR_RUNTIME_DESTROYED: return "RuntimeDestroyed";
        case DNP3_PARAM_ERROR_RUNTIME_CANNOT_BLOCK_WITHIN_ASYNC: return "RuntimeCannotBlockWithinAsync";
        case DNP3_PARAM_ERROR_LOGGING_ALREADY_CONFIGURED: return "LoggingAlreadyConfigured";
        case DNP3_PARAM_ERROR_POINT_DOES_NOT_EXIST: return "PointDoesNotExist";
        default: return "UnknownParamError";
    }
}
 
 
#define DNP3_FLAG_ONLINE 0x01
#define DNP3_FLAG_RESTART 0x02
#define DNP3_FLAG_COMM_LOST 0x04
#define DNP3_FLAG_REMOTE_FORCED 0x08
#define DNP3_FLAG_LOCAL_FORCED 0x10
#define DNP3_FLAG_CHATTER_FILTER 0x20
#define DNP3_FLAG_OVER_RANGE 0x20
#define DNP3_FLAG_DISCONTINUITY 0x40
#define DNP3_FLAG_REFERENCE_ERR 0x40
 
typedef enum dnp3_log_level_t
{
    DNP3_LOG_LEVEL_ERROR = 0,
    DNP3_LOG_LEVEL_WARN = 1,
    DNP3_LOG_LEVEL_INFO = 2,
    DNP3_LOG_LEVEL_DEBUG = 3,
    DNP3_LOG_LEVEL_TRACE = 4,
} dnp3_log_level_t;
 
static const char* dnp3_log_level_to_string(dnp3_log_level_t value)
{
    switch (value)
    {
        case DNP3_LOG_LEVEL_ERROR: return "Error";
        case DNP3_LOG_LEVEL_WARN: return "Warn";
        case DNP3_LOG_LEVEL_INFO: return "Info";
        case DNP3_LOG_LEVEL_DEBUG: return "Debug";
        case DNP3_LOG_LEVEL_TRACE: return "Trace";
        default: return "UnknownLogLevel";
    }
}
 
typedef enum dnp3_time_format_t
{
    DNP3_TIME_FORMAT_NONE = 0,
    DNP3_TIME_FORMAT_RFC3339 = 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_RFC3339: return "Rfc3339";
        case DNP3_TIME_FORMAT_SYSTEM: return "System";
        default: return "UnknownTimeFormat";
    }
}
 
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 "UnknownLogOutputFormat";
    }
}
 
typedef struct dnp3_logging_config_t dnp3_logging_config_t;
 
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()
{
    return (dnp3_logging_config_t)
    {
        .level = DNP3_LOG_LEVEL_INFO,
        .output_format = DNP3_LOG_OUTPUT_FORMAT_TEXT,
        .time_format = DNP3_TIME_FORMAT_SYSTEM,
        .print_level = true,
        .print_module_info = false,
    };
}
 
typedef struct dnp3_logger_t
{
    
    void (*on_message)(dnp3_log_level_t, const char*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_logger_t;
 
static dnp3_logger_t dnp3_logger_init(
    void (*on_message)(dnp3_log_level_t, const char*, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_logger_t result = 
    {
        .on_message = on_message,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
dnp3_param_error_t dnp3_configure_logging(dnp3_logging_config_t config, dnp3_logger_t logger);
 
 
typedef enum dnp3_app_decode_level_t
{
    DNP3_APP_DECODE_LEVEL_NOTHING = 0,
    DNP3_APP_DECODE_LEVEL_HEADER = 1,
    DNP3_APP_DECODE_LEVEL_OBJECT_HEADERS = 2,
    DNP3_APP_DECODE_LEVEL_OBJECT_VALUES = 3,
} dnp3_app_decode_level_t;
 
static const char* dnp3_app_decode_level_to_string(dnp3_app_decode_level_t value)
{
    switch (value)
    {
        case DNP3_APP_DECODE_LEVEL_NOTHING: return "Nothing";
        case DNP3_APP_DECODE_LEVEL_HEADER: return "Header";
        case DNP3_APP_DECODE_LEVEL_OBJECT_HEADERS: return "ObjectHeaders";
        case DNP3_APP_DECODE_LEVEL_OBJECT_VALUES: return "ObjectValues";
        default: return "UnknownAppDecodeLevel";
    }
}
 
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 "UnknownTransportDecodeLevel";
    }
}
 
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 "UnknownLinkDecodeLevel";
    }
}
 
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 "UnknownPhysDecodeLevel";
    }
}
 
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()
{
    return (dnp3_decode_level_t)
    {
        .application = DNP3_APP_DECODE_LEVEL_NOTHING,
        .transport = DNP3_TRANSPORT_DECODE_LEVEL_NOTHING,
        .link = DNP3_LINK_DECODE_LEVEL_NOTHING,
        .physical = DNP3_PHYS_DECODE_LEVEL_NOTHING,
    };
}
 
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()
{
    return (dnp3_runtime_config_t)
    {
        .num_core_threads = 0,
    };
}
 
dnp3_param_error_t dnp3_runtime_new(dnp3_runtime_config_t config, dnp3_runtime_t** out);
 
void dnp3_runtime_destroy(dnp3_runtime_t* runtime);
 
 
typedef struct dnp3_control_t dnp3_control_t;
 
typedef struct dnp3_control_t
{
    bool fir;
    bool fin;
    bool con;
    bool uns;
    uint8_t seq;
} dnp3_control_t;
 
static dnp3_control_t dnp3_control_init(bool fir, bool fin, bool con, bool uns, uint8_t seq)
{
    return (dnp3_control_t)
    {
        .fir = fir,
        .fin = fin,
        .con = con,
        .uns = uns,
        .seq = seq,
    };
}
 
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 "UnknownTripCloseCode";
    }
}
 
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 "PulseOn";
        case DNP3_OP_TYPE_PULSE_OFF: return "PulseOff";
        case DNP3_OP_TYPE_LATCH_ON: return "LatchOn";
        case DNP3_OP_TYPE_LATCH_OFF: return "LatchOff";
        default: return "UnknownOpType";
    }
}
 
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)
{
    return (dnp3_control_code_t)
    {
        .tcc = tcc,
        .clear = clear,
        .queue = false,
        .op_type = op_type,
    };
}
 
typedef struct dnp3_g12v1_t dnp3_g12v1_t;
 
typedef struct dnp3_g12v1_t
{
    dnp3_control_code_t code;
    uint8_t count;
    uint32_t on_time;
    uint32_t off_time;
} dnp3_g12v1_t;
 
static dnp3_g12v1_t dnp3_g12v1_init(dnp3_control_code_t code, uint8_t count, uint32_t on_time, uint32_t off_time)
{
    return (dnp3_g12v1_t)
    {
        .code = code,
        .count = count,
        .on_time = on_time,
        .off_time = off_time,
    };
}
 
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)
{
    return (dnp3_flags_t)
    {
        .value = value,
    };
}
 
typedef enum dnp3_time_quality_t
{
    DNP3_TIME_QUALITY_SYNCHRONIZED = 0,
    DNP3_TIME_QUALITY_NOT_SYNCHRONIZED = 1,
    DNP3_TIME_QUALITY_INVALID = 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: return "Synchronized";
        case DNP3_TIME_QUALITY_NOT_SYNCHRONIZED: return "NotSynchronized";
        case DNP3_TIME_QUALITY_INVALID: return "Invalid";
        default: return "UnknownTimeQuality";
    }
}
 
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_init(uint64_t value, dnp3_time_quality_t quality)
{
    return (dnp3_timestamp_t)
    {
        .value = value,
        .quality = quality,
    };
}
 
dnp3_timestamp_t dnp3_timestamp_invalid();
 
dnp3_timestamp_t dnp3_timestamp_synchronized(uint64_t value);
 
dnp3_timestamp_t dnp3_timestamp_not_synchronized(uint64_t 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 "DeterminedOff";
        case DNP3_DOUBLE_BIT_DETERMINED_ON: return "DeterminedOn";
        case DNP3_DOUBLE_BIT_INDETERMINATE: return "Indeterminate";
        default: return "UnknownDoubleBit";
    }
}
 
typedef struct dnp3_binary_t dnp3_binary_t;
 
typedef struct dnp3_binary_t
{
    uint16_t index;
    bool value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_binary_t;
 
static dnp3_binary_t dnp3_binary_init(uint16_t index, bool value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    return (dnp3_binary_t)
    {
        .index = index,
        .value = value,
        .flags = flags,
        .time = time,
    };
}
 
typedef struct dnp3_binary_iterator_t dnp3_binary_iterator_t;
 
dnp3_binary_t* dnp3_binary_next(dnp3_binary_iterator_t* it);
 
 
typedef struct dnp3_double_bit_binary_t dnp3_double_bit_binary_t;
 
typedef struct dnp3_double_bit_binary_t
{
    uint16_t index;
    dnp3_double_bit_t value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_double_bit_binary_t;
 
static dnp3_double_bit_binary_t dnp3_double_bit_binary_init(uint16_t index, dnp3_double_bit_t value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    return (dnp3_double_bit_binary_t)
    {
        .index = index,
        .value = value,
        .flags = flags,
        .time = time,
    };
}
 
typedef struct dnp3_double_bit_binary_iterator_t dnp3_double_bit_binary_iterator_t;
 
dnp3_double_bit_binary_t* dnp3_doublebitbinary_next(dnp3_double_bit_binary_iterator_t* it);
 
 
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)
{
    return (dnp3_binary_output_status_t)
    {
        .index = index,
        .value = value,
        .flags = flags,
        .time = time,
    };
}
 
typedef struct dnp3_binary_output_status_iterator_t dnp3_binary_output_status_iterator_t;
 
dnp3_binary_output_status_t* dnp3_binaryoutputstatus_next(dnp3_binary_output_status_iterator_t* it);
 
 
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)
{
    return (dnp3_counter_t)
    {
        .index = index,
        .value = value,
        .flags = flags,
        .time = time,
    };
}
 
typedef struct dnp3_counter_iterator_t dnp3_counter_iterator_t;
 
dnp3_counter_t* dnp3_counter_next(dnp3_counter_iterator_t* it);
 
 
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)
{
    return (dnp3_frozen_counter_t)
    {
        .index = index,
        .value = value,
        .flags = flags,
        .time = time,
    };
}
 
typedef struct dnp3_frozen_counter_iterator_t dnp3_frozen_counter_iterator_t;
 
dnp3_frozen_counter_t* dnp3_frozencounter_next(dnp3_frozen_counter_iterator_t* it);
 
 
typedef struct dnp3_analog_t dnp3_analog_t;
 
typedef struct dnp3_analog_t
{
    uint16_t index;
    double value;
    dnp3_flags_t flags;
    dnp3_timestamp_t time;
} dnp3_analog_t;
 
static dnp3_analog_t dnp3_analog_init(uint16_t index, double value, dnp3_flags_t flags, dnp3_timestamp_t time)
{
    return (dnp3_analog_t)
    {
        .index = index,
        .value = value,
        .flags = flags,
        .time = time,
    };
}
 
typedef struct dnp3_analog_iterator_t dnp3_analog_iterator_t;
 
dnp3_analog_t* dnp3_analog_next(dnp3_analog_iterator_t* it);
 
 
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)
{
    return (dnp3_analog_output_status_t)
    {
        .index = index,
        .value = value,
        .flags = flags,
        .time = time,
    };
}
 
typedef struct dnp3_analog_output_status_iterator_t dnp3_analog_output_status_iterator_t;
 
dnp3_analog_output_status_t* dnp3_analogoutputstatus_next(dnp3_analog_output_status_iterator_t* it);
 
 
typedef struct dnp3_byte_t dnp3_byte_t;
 
typedef struct dnp3_byte_t
{
    uint8_t value;
} dnp3_byte_t;
 
static dnp3_byte_t dnp3_byte_init(uint8_t value)
{
    return (dnp3_byte_t)
    {
        .value = value,
    };
}
 
typedef struct dnp3_byte_iterator_t dnp3_byte_iterator_t;
 
dnp3_byte_t* dnp3_byte_next(dnp3_byte_iterator_t* it);
 
 
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)
{
    return (dnp3_octet_string_t)
    {
        .index = index,
        .value = value,
    };
}
 
typedef struct dnp3_octet_string_iterator_t dnp3_octet_string_iterator_t;
 
dnp3_octet_string_t* dnp3_octetstring_next(dnp3_octet_string_iterator_t* it);
 
 
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 "UnknownPortState";
    }
}
 
typedef struct dnp3_port_state_listener_t
{
    
    void (*on_change)(dnp3_port_state_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_port_state_listener_t;
 
static dnp3_port_state_listener_t dnp3_port_state_listener_init(
    void (*on_change)(dnp3_port_state_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_port_state_listener_t result = 
    {
        .on_change = on_change,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
typedef enum dnp3_variation_t
{
    DNP3_VARIATION_GROUP1_VAR0 = 0,
    DNP3_VARIATION_GROUP1_VAR1 = 1,
    DNP3_VARIATION_GROUP1_VAR2 = 2,
    DNP3_VARIATION_GROUP2_VAR0 = 3,
    DNP3_VARIATION_GROUP2_VAR1 = 4,
    DNP3_VARIATION_GROUP2_VAR2 = 5,
    DNP3_VARIATION_GROUP2_VAR3 = 6,
    DNP3_VARIATION_GROUP3_VAR0 = 7,
    DNP3_VARIATION_GROUP3_VAR1 = 8,
    DNP3_VARIATION_GROUP3_VAR2 = 9,
    DNP3_VARIATION_GROUP4_VAR0 = 10,
    DNP3_VARIATION_GROUP4_VAR1 = 11,
    DNP3_VARIATION_GROUP4_VAR2 = 12,
    DNP3_VARIATION_GROUP4_VAR3 = 13,
    DNP3_VARIATION_GROUP10_VAR0 = 14,
    DNP3_VARIATION_GROUP10_VAR1 = 15,
    DNP3_VARIATION_GROUP10_VAR2 = 16,
    DNP3_VARIATION_GROUP11_VAR0 = 17,
    DNP3_VARIATION_GROUP11_VAR1 = 18,
    DNP3_VARIATION_GROUP11_VAR2 = 19,
    DNP3_VARIATION_GROUP12_VAR0 = 20,
    DNP3_VARIATION_GROUP12_VAR1 = 21,
    DNP3_VARIATION_GROUP20_VAR0 = 22,
    DNP3_VARIATION_GROUP20_VAR1 = 23,
    DNP3_VARIATION_GROUP20_VAR2 = 24,
    DNP3_VARIATION_GROUP20_VAR5 = 25,
    DNP3_VARIATION_GROUP20_VAR6 = 26,
    DNP3_VARIATION_GROUP21_VAR0 = 27,
    DNP3_VARIATION_GROUP21_VAR1 = 28,
    DNP3_VARIATION_GROUP21_VAR2 = 29,
    DNP3_VARIATION_GROUP21_VAR5 = 30,
    DNP3_VARIATION_GROUP21_VAR6 = 31,
    DNP3_VARIATION_GROUP21_VAR9 = 32,
    DNP3_VARIATION_GROUP21_VAR10 = 33,
    DNP3_VARIATION_GROUP22_VAR0 = 34,
    DNP3_VARIATION_GROUP22_VAR1 = 35,
    DNP3_VARIATION_GROUP22_VAR2 = 36,
    DNP3_VARIATION_GROUP22_VAR5 = 37,
    DNP3_VARIATION_GROUP22_VAR6 = 38,
    DNP3_VARIATION_GROUP23_VAR0 = 39,
    DNP3_VARIATION_GROUP23_VAR1 = 40,
    DNP3_VARIATION_GROUP23_VAR2 = 41,
    DNP3_VARIATION_GROUP23_VAR5 = 42,
    DNP3_VARIATION_GROUP23_VAR6 = 43,
    DNP3_VARIATION_GROUP30_VAR0 = 44,
    DNP3_VARIATION_GROUP30_VAR1 = 45,
    DNP3_VARIATION_GROUP30_VAR2 = 46,
    DNP3_VARIATION_GROUP30_VAR3 = 47,
    DNP3_VARIATION_GROUP30_VAR4 = 48,
    DNP3_VARIATION_GROUP30_VAR5 = 49,
    DNP3_VARIATION_GROUP30_VAR6 = 50,
    DNP3_VARIATION_GROUP32_VAR0 = 51,
    DNP3_VARIATION_GROUP32_VAR1 = 52,
    DNP3_VARIATION_GROUP32_VAR2 = 53,
    DNP3_VARIATION_GROUP32_VAR3 = 54,
    DNP3_VARIATION_GROUP32_VAR4 = 55,
    DNP3_VARIATION_GROUP32_VAR5 = 56,
    DNP3_VARIATION_GROUP32_VAR6 = 57,
    DNP3_VARIATION_GROUP32_VAR7 = 58,
    DNP3_VARIATION_GROUP32_VAR8 = 59,
    DNP3_VARIATION_GROUP40_VAR0 = 60,
    DNP3_VARIATION_GROUP40_VAR1 = 61,
    DNP3_VARIATION_GROUP40_VAR2 = 62,
    DNP3_VARIATION_GROUP40_VAR3 = 63,
    DNP3_VARIATION_GROUP40_VAR4 = 64,
    DNP3_VARIATION_GROUP41_VAR0 = 65,
    DNP3_VARIATION_GROUP41_VAR1 = 66,
    DNP3_VARIATION_GROUP41_VAR2 = 67,
    DNP3_VARIATION_GROUP41_VAR3 = 68,
    DNP3_VARIATION_GROUP41_VAR4 = 69,
    DNP3_VARIATION_GROUP42_VAR0 = 70,
    DNP3_VARIATION_GROUP42_VAR1 = 71,
    DNP3_VARIATION_GROUP42_VAR2 = 72,
    DNP3_VARIATION_GROUP42_VAR3 = 73,
    DNP3_VARIATION_GROUP42_VAR4 = 74,
    DNP3_VARIATION_GROUP42_VAR5 = 75,
    DNP3_VARIATION_GROUP42_VAR6 = 76,
    DNP3_VARIATION_GROUP42_VAR7 = 77,
    DNP3_VARIATION_GROUP42_VAR8 = 78,
    DNP3_VARIATION_GROUP50_VAR1 = 79,
    DNP3_VARIATION_GROUP50_VAR3 = 80,
    DNP3_VARIATION_GROUP50_VAR4 = 81,
    DNP3_VARIATION_GROUP51_VAR1 = 82,
    DNP3_VARIATION_GROUP51_VAR2 = 83,
    DNP3_VARIATION_GROUP52_VAR1 = 84,
    DNP3_VARIATION_GROUP52_VAR2 = 85,
    DNP3_VARIATION_GROUP60_VAR1 = 86,
    DNP3_VARIATION_GROUP60_VAR2 = 87,
    DNP3_VARIATION_GROUP60_VAR3 = 88,
    DNP3_VARIATION_GROUP60_VAR4 = 89,
    DNP3_VARIATION_GROUP80_VAR1 = 90,
    DNP3_VARIATION_GROUP110 = 91,
    DNP3_VARIATION_GROUP111 = 92,
} dnp3_variation_t;
 
static const char* dnp3_variation_to_string(dnp3_variation_t value)
{
    switch (value)
    {
        case DNP3_VARIATION_GROUP1_VAR0: return "Group1Var0";
        case DNP3_VARIATION_GROUP1_VAR1: return "Group1Var1";
        case DNP3_VARIATION_GROUP1_VAR2: return "Group1Var2";
        case DNP3_VARIATION_GROUP2_VAR0: return "Group2Var0";
        case DNP3_VARIATION_GROUP2_VAR1: return "Group2Var1";
        case DNP3_VARIATION_GROUP2_VAR2: return "Group2Var2";
        case DNP3_VARIATION_GROUP2_VAR3: return "Group2Var3";
        case DNP3_VARIATION_GROUP3_VAR0: return "Group3Var0";
        case DNP3_VARIATION_GROUP3_VAR1: return "Group3Var1";
        case DNP3_VARIATION_GROUP3_VAR2: return "Group3Var2";
        case DNP3_VARIATION_GROUP4_VAR0: return "Group4Var0";
        case DNP3_VARIATION_GROUP4_VAR1: return "Group4Var1";
        case DNP3_VARIATION_GROUP4_VAR2: return "Group4Var2";
        case DNP3_VARIATION_GROUP4_VAR3: return "Group4Var3";
        case DNP3_VARIATION_GROUP10_VAR0: return "Group10Var0";
        case DNP3_VARIATION_GROUP10_VAR1: return "Group10Var1";
        case DNP3_VARIATION_GROUP10_VAR2: return "Group10Var2";
        case DNP3_VARIATION_GROUP11_VAR0: return "Group11Var0";
        case DNP3_VARIATION_GROUP11_VAR1: return "Group11Var1";
        case DNP3_VARIATION_GROUP11_VAR2: return "Group11Var2";
        case DNP3_VARIATION_GROUP12_VAR0: return "Group12Var0";
        case DNP3_VARIATION_GROUP12_VAR1: return "Group12Var1";
        case DNP3_VARIATION_GROUP20_VAR0: return "Group20Var0";
        case DNP3_VARIATION_GROUP20_VAR1: return "Group20Var1";
        case DNP3_VARIATION_GROUP20_VAR2: return "Group20Var2";
        case DNP3_VARIATION_GROUP20_VAR5: return "Group20Var5";
        case DNP3_VARIATION_GROUP20_VAR6: return "Group20Var6";
        case DNP3_VARIATION_GROUP21_VAR0: return "Group21Var0";
        case DNP3_VARIATION_GROUP21_VAR1: return "Group21Var1";
        case DNP3_VARIATION_GROUP21_VAR2: return "Group21Var2";
        case DNP3_VARIATION_GROUP21_VAR5: return "Group21Var5";
        case DNP3_VARIATION_GROUP21_VAR6: return "Group21Var6";
        case DNP3_VARIATION_GROUP21_VAR9: return "Group21Var9";
        case DNP3_VARIATION_GROUP21_VAR10: return "Group21Var10";
        case DNP3_VARIATION_GROUP22_VAR0: return "Group22Var0";
        case DNP3_VARIATION_GROUP22_VAR1: return "Group22Var1";
        case DNP3_VARIATION_GROUP22_VAR2: return "Group22Var2";
        case DNP3_VARIATION_GROUP22_VAR5: return "Group22Var5";
        case DNP3_VARIATION_GROUP22_VAR6: return "Group22Var6";
        case DNP3_VARIATION_GROUP23_VAR0: return "Group23Var0";
        case DNP3_VARIATION_GROUP23_VAR1: return "Group23Var1";
        case DNP3_VARIATION_GROUP23_VAR2: return "Group23Var2";
        case DNP3_VARIATION_GROUP23_VAR5: return "Group23Var5";
        case DNP3_VARIATION_GROUP23_VAR6: return "Group23Var6";
        case DNP3_VARIATION_GROUP30_VAR0: return "Group30Var0";
        case DNP3_VARIATION_GROUP30_VAR1: return "Group30Var1";
        case DNP3_VARIATION_GROUP30_VAR2: return "Group30Var2";
        case DNP3_VARIATION_GROUP30_VAR3: return "Group30Var3";
        case DNP3_VARIATION_GROUP30_VAR4: return "Group30Var4";
        case DNP3_VARIATION_GROUP30_VAR5: return "Group30Var5";
        case DNP3_VARIATION_GROUP30_VAR6: return "Group30Var6";
        case DNP3_VARIATION_GROUP32_VAR0: return "Group32Var0";
        case DNP3_VARIATION_GROUP32_VAR1: return "Group32Var1";
        case DNP3_VARIATION_GROUP32_VAR2: return "Group32Var2";
        case DNP3_VARIATION_GROUP32_VAR3: return "Group32Var3";
        case DNP3_VARIATION_GROUP32_VAR4: return "Group32Var4";
        case DNP3_VARIATION_GROUP32_VAR5: return "Group32Var5";
        case DNP3_VARIATION_GROUP32_VAR6: return "Group32Var6";
        case DNP3_VARIATION_GROUP32_VAR7: return "Group32Var7";
        case DNP3_VARIATION_GROUP32_VAR8: return "Group32Var8";
        case DNP3_VARIATION_GROUP40_VAR0: return "Group40Var0";
        case DNP3_VARIATION_GROUP40_VAR1: return "Group40Var1";
        case DNP3_VARIATION_GROUP40_VAR2: return "Group40Var2";
        case DNP3_VARIATION_GROUP40_VAR3: return "Group40Var3";
        case DNP3_VARIATION_GROUP40_VAR4: return "Group40Var4";
        case DNP3_VARIATION_GROUP41_VAR0: return "Group41Var0";
        case DNP3_VARIATION_GROUP41_VAR1: return "Group41Var1";
        case DNP3_VARIATION_GROUP41_VAR2: return "Group41Var2";
        case DNP3_VARIATION_GROUP41_VAR3: return "Group41Var3";
        case DNP3_VARIATION_GROUP41_VAR4: return "Group41Var4";
        case DNP3_VARIATION_GROUP42_VAR0: return "Group42Var0";
        case DNP3_VARIATION_GROUP42_VAR1: return "Group42Var1";
        case DNP3_VARIATION_GROUP42_VAR2: return "Group42Var2";
        case DNP3_VARIATION_GROUP42_VAR3: return "Group42Var3";
        case DNP3_VARIATION_GROUP42_VAR4: return "Group42Var4";
        case DNP3_VARIATION_GROUP42_VAR5: return "Group42Var5";
        case DNP3_VARIATION_GROUP42_VAR6: return "Group42Var6";
        case DNP3_VARIATION_GROUP42_VAR7: return "Group42Var7";
        case DNP3_VARIATION_GROUP42_VAR8: return "Group42Var8";
        case DNP3_VARIATION_GROUP50_VAR1: return "Group50Var1";
        case DNP3_VARIATION_GROUP50_VAR3: return "Group50Var3";
        case DNP3_VARIATION_GROUP50_VAR4: return "Group50Var4";
        case DNP3_VARIATION_GROUP51_VAR1: return "Group51Var1";
        case DNP3_VARIATION_GROUP51_VAR2: return "Group51Var2";
        case DNP3_VARIATION_GROUP52_VAR1: return "Group52Var1";
        case DNP3_VARIATION_GROUP52_VAR2: return "Group52Var2";
        case DNP3_VARIATION_GROUP60_VAR1: return "Group60Var1";
        case DNP3_VARIATION_GROUP60_VAR2: return "Group60Var2";
        case DNP3_VARIATION_GROUP60_VAR3: return "Group60Var3";
        case DNP3_VARIATION_GROUP60_VAR4: return "Group60Var4";
        case DNP3_VARIATION_GROUP80_VAR1: return "Group80Var1";
        case DNP3_VARIATION_GROUP110: return "Group110";
        case DNP3_VARIATION_GROUP111: return "Group111";
        default: return "UnknownVariation";
    }
}
 
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()
{
    return (dnp3_retry_strategy_t)
    {
        .min_delay = 1000,
        .max_delay = 10000,
    };
}
 
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 "UnknownDataBits";
    }
}
 
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 "UnknownFlowControl";
    }
}
 
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 "UnknownParity";
    }
}
 
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 "UnknownStopBits";
    }
}
 
typedef struct dnp3_serial_port_settings_t dnp3_serial_port_settings_t;
 
typedef struct dnp3_serial_port_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_port_settings_t;
 
static dnp3_serial_port_settings_t dnp3_serial_port_settings_init()
{
    return (dnp3_serial_port_settings_t)
    {
        .baud_rate = 9600,
        .data_bits = DNP3_DATA_BITS_EIGHT,
        .flow_control = DNP3_FLOW_CONTROL_NONE,
        .parity = DNP3_PARITY_NONE,
        .stop_bits = DNP3_STOP_BITS_ONE,
    };
}
 
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 "UnknownLinkErrorMode";
    }
}
 
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 "UnsolicitedResponse";
        default: return "UnknownResponseFunction";
    }
}
 
typedef struct dnp3_iin1_t dnp3_iin1_t;
 
typedef struct dnp3_iin1_t
{
    uint8_t value;
} dnp3_iin1_t;
 
static dnp3_iin1_t dnp3_iin1_init(uint8_t value)
{
    return (dnp3_iin1_t)
    {
        .value = value,
    };
}
 
typedef enum dnp3_iin1_flag_t
{
    DNP3_IIN1_FLAG_BROADCAST = 0,
    DNP3_IIN1_FLAG_CLASS1_EVENTS = 1,
    DNP3_IIN1_FLAG_CLASS2_EVENTS = 2,
    DNP3_IIN1_FLAG_CLASS3_EVENTS = 3,
    DNP3_IIN1_FLAG_NEED_TIME = 4,
    DNP3_IIN1_FLAG_LOCAL_CONTROL = 5,
    DNP3_IIN1_FLAG_DEVICE_TROUBLE = 6,
    DNP3_IIN1_FLAG_DEVICE_RESTART = 7,
} dnp3_iin1_flag_t;
 
static const char* dnp3_iin1_flag_to_string(dnp3_iin1_flag_t value)
{
    switch (value)
    {
        case DNP3_IIN1_FLAG_BROADCAST: return "Broadcast";
        case DNP3_IIN1_FLAG_CLASS1_EVENTS: return "Class1Events";
        case DNP3_IIN1_FLAG_CLASS2_EVENTS: return "Class2Events";
        case DNP3_IIN1_FLAG_CLASS3_EVENTS: return "Class3Events";
        case DNP3_IIN1_FLAG_NEED_TIME: return "NeedTime";
        case DNP3_IIN1_FLAG_LOCAL_CONTROL: return "LocalControl";
        case DNP3_IIN1_FLAG_DEVICE_TROUBLE: return "DeviceTrouble";
        case DNP3_IIN1_FLAG_DEVICE_RESTART: return "DeviceRestart";
        default: return "UnknownIIN1Flag";
    }
}
 
bool dnp3_iin1_is_set(dnp3_iin1_t* iin1, dnp3_iin1_flag_t flag);
 
 
typedef struct dnp3_iin2_t dnp3_iin2_t;
 
typedef struct dnp3_iin2_t
{
    uint8_t value;
} dnp3_iin2_t;
 
static dnp3_iin2_t dnp3_iin2_init(uint8_t value)
{
    return (dnp3_iin2_t)
    {
        .value = value,
    };
}
 
typedef enum dnp3_iin2_flag_t
{
    DNP3_IIN2_FLAG_NO_FUNC_CODE_SUPPORT = 0,
    DNP3_IIN2_FLAG_OBJECT_UNKNOWN = 1,
    DNP3_IIN2_FLAG_PARAMETER_ERROR = 2,
    DNP3_IIN2_FLAG_EVENT_BUFFER_OVERFLOW = 3,
    DNP3_IIN2_FLAG_ALREADY_EXECUTING = 4,
    DNP3_IIN2_FLAG_CONFIG_CORRUPT = 5,
} dnp3_iin2_flag_t;
 
static const char* dnp3_iin2_flag_to_string(dnp3_iin2_flag_t value)
{
    switch (value)
    {
        case DNP3_IIN2_FLAG_NO_FUNC_CODE_SUPPORT: return "NoFuncCodeSupport";
        case DNP3_IIN2_FLAG_OBJECT_UNKNOWN: return "ObjectUnknown";
        case DNP3_IIN2_FLAG_PARAMETER_ERROR: return "ParameterError";
        case DNP3_IIN2_FLAG_EVENT_BUFFER_OVERFLOW: return "EventBufferOverflow";
        case DNP3_IIN2_FLAG_ALREADY_EXECUTING: return "AlreadyExecuting";
        case DNP3_IIN2_FLAG_CONFIG_CORRUPT: return "ConfigCorrupt";
        default: return "UnknownIIN2Flag";
    }
}
 
bool dnp3_iin2_is_set(dnp3_iin2_t* iin2, dnp3_iin2_flag_t flag);
 
 
typedef struct dnp3_iin_t dnp3_iin_t;
 
typedef struct dnp3_iin_t
{
    dnp3_iin1_t iin1;
    dnp3_iin2_t iin2;
} dnp3_iin_t;
 
static dnp3_iin_t dnp3_iin_init(dnp3_iin1_t iin1, dnp3_iin2_t iin2)
{
    return (dnp3_iin_t)
    {
        .iin1 = iin1,
        .iin2 = iin2,
    };
}
 
typedef struct dnp3_response_header_t dnp3_response_header_t;
 
typedef struct dnp3_response_header_t
{
    dnp3_control_t control;
    dnp3_response_function_t func;
    dnp3_iin_t iin;
} dnp3_response_header_t;
 
static dnp3_response_header_t dnp3_response_header_init(dnp3_control_t control, dnp3_response_function_t func, dnp3_iin_t iin)
{
    return (dnp3_response_header_t)
    {
        .control = control,
        .func = func,
        .iin = iin,
    };
}
 
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_PREFIX8 = 5,
    DNP3_QUALIFIER_CODE_COUNT_AND_PREFIX16 = 6,
    DNP3_QUALIFIER_CODE_FREE_FORMAT16 = 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 "AllObjects";
        case DNP3_QUALIFIER_CODE_COUNT8: return "Count8";
        case DNP3_QUALIFIER_CODE_COUNT16: return "Count16";
        case DNP3_QUALIFIER_CODE_COUNT_AND_PREFIX8: return "CountAndPrefix8";
        case DNP3_QUALIFIER_CODE_COUNT_AND_PREFIX16: return "CountAndPrefix16";
        case DNP3_QUALIFIER_CODE_FREE_FORMAT16: return "FreeFormat16";
        default: return "UnknownQualifierCode";
    }
}
 
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;
} dnp3_header_info_t;
 
static dnp3_header_info_t dnp3_header_info_init(dnp3_variation_t variation, dnp3_qualifier_code_t qualifier)
{
    return (dnp3_header_info_t)
    {
        .variation = variation,
        .qualifier = qualifier,
    };
}
 
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 "StartupIntegrity";
        case DNP3_READ_TYPE_UNSOLICITED: return "Unsolicited";
        case DNP3_READ_TYPE_SINGLE_POLL: return "SinglePoll";
        case DNP3_READ_TYPE_PERIODIC_POLL: return "PeriodicPoll";
        default: return "UnknownReadType";
    }
}
 
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)(dnp3_header_info_t, dnp3_binary_iterator_t*, void*);
    
    void (*handle_double_bit_binary)(dnp3_header_info_t, dnp3_double_bit_binary_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)(dnp3_header_info_t, dnp3_analog_iterator_t*, void*);
    
    void (*handle_analog_output_status)(dnp3_header_info_t, dnp3_analog_output_status_iterator_t*, void*);
    
    void (*handle_octet_string)(dnp3_header_info_t, dnp3_octet_string_iterator_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_read_handler_t;
 
static dnp3_read_handler_t dnp3_read_handler_init(
    void (*begin_fragment)(dnp3_read_type_t, dnp3_response_header_t, void*),
    void (*end_fragment)(dnp3_read_type_t, dnp3_response_header_t, void*),
    void (*handle_binary)(dnp3_header_info_t, dnp3_binary_iterator_t*, void*),
    void (*handle_double_bit_binary)(dnp3_header_info_t, dnp3_double_bit_binary_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)(dnp3_header_info_t, dnp3_analog_iterator_t*, void*),
    void (*handle_analog_output_status)(dnp3_header_info_t, dnp3_analog_output_status_iterator_t*, void*),
    void (*handle_octet_string)(dnp3_header_info_t, dnp3_octet_string_iterator_t*, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_read_handler_t result = 
    {
        .begin_fragment = begin_fragment,
        .end_fragment = end_fragment,
        .handle_binary = handle_binary,
        .handle_double_bit_binary = handle_double_bit_binary,
        .handle_binary_output_status = handle_binary_output_status,
        .handle_counter = handle_counter,
        .handle_frozen_counter = handle_frozen_counter,
        .handle_analog = handle_analog,
        .handle_analog_output_status = handle_analog_output_status,
        .handle_octet_string = handle_octet_string,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
typedef struct dnp3_endpoint_list_t dnp3_endpoint_list_t;
 
dnp3_endpoint_list_t* dnp3_endpoint_list_new(const char* main_endpoint);
 
void dnp3_endpoint_list_destroy(dnp3_endpoint_list_t* list);
 
void dnp3_endpoint_list_add(dnp3_endpoint_list_t* list, const char* endpoint);
 
 
typedef struct dnp3_master_channel_config_t dnp3_master_channel_config_t;
 
typedef struct dnp3_master_channel_config_t
{
    uint16_t address;
    dnp3_decode_level_t decode_level;
    uint64_t response_timeout;
    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)
{
    return (dnp3_master_channel_config_t)
    {
        .address = address,
        .decode_level = dnp3_decode_level_init(),
        .response_timeout = 5000,
        .tx_buffer_size = 2048,
        .rx_buffer_size = 2048,
    };
}
 
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 "WaitAfterFailedConnect";
        case DNP3_CLIENT_STATE_WAIT_AFTER_DISCONNECT: return "WaitAfterDisconnect";
        case DNP3_CLIENT_STATE_SHUTDOWN: return "Shutdown";
        default: return "UnknownClientState";
    }
}
 
typedef struct dnp3_client_state_listener_t
{
    
    void (*on_change)(dnp3_client_state_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_client_state_listener_t;
 
static dnp3_client_state_listener_t dnp3_client_state_listener_init(
    void (*on_change)(dnp3_client_state_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_client_state_listener_t result = 
    {
        .on_change = on_change,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
typedef struct dnp3_master_channel_t dnp3_master_channel_t;
 
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()
{
    return (dnp3_connect_strategy_t)
    {
        .min_connect_delay = 1000,
        .max_connect_delay = 10000,
        .reconnect_delay = 1000,
    };
}
 
dnp3_param_error_t dnp3_master_channel_create_tcp(dnp3_runtime_t* runtime, dnp3_link_error_mode_t link_error_mode, dnp3_master_channel_config_t config, dnp3_endpoint_list_t* endpoints, dnp3_connect_strategy_t connect_strategy, dnp3_client_state_listener_t listener, dnp3_master_channel_t** out);
 
dnp3_param_error_t dnp3_master_channel_create_serial(dnp3_runtime_t* runtime, dnp3_master_channel_config_t config, const char* path, dnp3_serial_port_settings_t serial_params, uint64_t open_retry_delay, dnp3_port_state_listener_t listener, dnp3_master_channel_t** out);
 
void dnp3_master_channel_destroy(dnp3_master_channel_t* channel);
 
dnp3_param_error_t dnp3_master_channel_enable(dnp3_master_channel_t* channel);
 
dnp3_param_error_t dnp3_master_channel_disable(dnp3_master_channel_t* channel);
 
typedef struct dnp3_association_id_t dnp3_association_id_t;
 
typedef struct dnp3_association_id_t
{
    uint16_t address;
} dnp3_association_id_t;
 
typedef struct dnp3_poll_id_t dnp3_poll_id_t;
 
typedef struct dnp3_poll_id_t
{
    uint16_t association_id;
    uint64_t id;
} dnp3_poll_id_t;
 
typedef struct dnp3_event_classes_t dnp3_event_classes_t;
 
typedef struct dnp3_event_classes_t
{
    bool class1;
    bool class2;
    bool class3;
} dnp3_event_classes_t;
 
static dnp3_event_classes_t dnp3_event_classes_init(bool class1, bool class2, bool class3)
{
    return (dnp3_event_classes_t)
    {
        .class1 = class1,
        .class2 = class2,
        .class3 = class3,
    };
}
 
dnp3_event_classes_t dnp3_event_classes_all();
 
dnp3_event_classes_t dnp3_event_classes_none();
 
 
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)
{
    return (dnp3_classes_t)
    {
        .class0 = class0,
        .class1 = class1,
        .class2 = class2,
        .class3 = class3,
    };
}
 
dnp3_classes_t dnp3_classes_all();
 
dnp3_classes_t dnp3_classes_none();
 
 
typedef enum dnp3_auto_time_sync_t
{
    DNP3_AUTO_TIME_SYNC_NONE = 0,
    DNP3_AUTO_TIME_SYNC_LAN = 1,
    DNP3_AUTO_TIME_SYNC_NON_LAN = 2,
} dnp3_auto_time_sync_t;
 
static const char* dnp3_auto_time_sync_to_string(dnp3_auto_time_sync_t value)
{
    switch (value)
    {
        case DNP3_AUTO_TIME_SYNC_NONE: return "None";
        case DNP3_AUTO_TIME_SYNC_LAN: return "Lan";
        case DNP3_AUTO_TIME_SYNC_NON_LAN: return "NonLan";
        default: return "UnknownAutoTimeSync";
    }
}
 
typedef struct dnp3_association_config_t dnp3_association_config_t;
 
typedef struct dnp3_association_config_t
{
    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)
{
    return (dnp3_association_config_t)
    {
        .disable_unsol_classes = disable_unsol_classes,
        .enable_unsol_classes = enable_unsol_classes,
        .startup_integrity_classes = startup_integrity_classes,
        .auto_time_sync = DNP3_AUTO_TIME_SYNC_NONE,
        .auto_tasks_retry_strategy = dnp3_retry_strategy_init(),
        .keep_alive_timeout = 60,
        .auto_integrity_scan_on_buffer_overflow = true,
        .event_scan_on_events_available = event_scan_on_events_available,
        .max_queued_user_requests = 16,
    };
}
 
typedef struct dnp3_timestamp_utc_t dnp3_timestamp_utc_t;
 
typedef struct dnp3_timestamp_utc_t
{
    uint64_t value;
    bool is_valid;
} dnp3_timestamp_utc_t;
 
static dnp3_timestamp_utc_t dnp3_timestamp_utc_init(uint64_t value, bool is_valid)
{
    return (dnp3_timestamp_utc_t)
    {
        .value = value,
        .is_valid = is_valid,
    };
}
 
dnp3_timestamp_utc_t dnp3_timestamp_utc_valid(uint64_t value);
 
dnp3_timestamp_utc_t dnp3_timestamp_utc_invalid();
 
 
typedef struct dnp3_association_handler_t
{
    
    dnp3_timestamp_utc_t (*get_current_time)(void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_association_handler_t;
 
static dnp3_association_handler_t dnp3_association_handler_init(
    dnp3_timestamp_utc_t (*get_current_time)(void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_association_handler_t result = 
    {
        .get_current_time = get_current_time,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
typedef struct dnp3_request_t dnp3_request_t;
 
dnp3_request_t* dnp3_request_new();
 
dnp3_request_t* dnp3_request_new_class(bool class0, bool class1, bool class2, bool class3);
 
void dnp3_request_destroy(dnp3_request_t* request);
 
void dnp3_request_add_one_byte_header(dnp3_request_t* request, dnp3_variation_t variation, uint8_t start, uint8_t stop);
 
void dnp3_request_add_two_byte_header(dnp3_request_t* request, dnp3_variation_t variation, uint16_t start, uint16_t stop);
 
void dnp3_request_add_all_objects_header(dnp3_request_t* request, dnp3_variation_t variation);
 
 
dnp3_param_error_t dnp3_master_channel_add_association(dnp3_master_channel_t* channel, uint16_t address, dnp3_association_config_t config, dnp3_read_handler_t read_handler, dnp3_association_handler_t association_handler, dnp3_association_id_t* out);
 
dnp3_param_error_t dnp3_master_channel_remove_association(dnp3_master_channel_t* channel, dnp3_association_id_t id);
 
dnp3_param_error_t dnp3_master_channel_add_poll(dnp3_master_channel_t* channel, 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* channel, dnp3_poll_id_t poll_id);
 
dnp3_param_error_t dnp3_master_channel_demand_poll(dnp3_master_channel_t* channel, dnp3_poll_id_t poll_id);
 
dnp3_param_error_t dnp3_master_channel_set_decode_level(dnp3_master_channel_t* channel, dnp3_decode_level_t decode_level);
 
dnp3_param_error_t dnp3_master_channel_get_decode_level(dnp3_master_channel_t* channel, dnp3_decode_level_t* out);
 
typedef enum dnp3_read_result_t
{
    DNP3_READ_RESULT_SUCCESS = 0,
    DNP3_READ_RESULT_TOO_MANY_REQUESTS = 1,
    DNP3_READ_RESULT_BAD_RESPONSE = 2,
    DNP3_READ_RESULT_RESPONSE_TIMEOUT = 3,
    DNP3_READ_RESULT_WRITE_ERROR = 4,
    DNP3_READ_RESULT_NO_CONNECTION = 5,
    DNP3_READ_RESULT_SHUTDOWN = 6,
    DNP3_READ_RESULT_ASSOCIATION_REMOVED = 7,
} dnp3_read_result_t;
 
static const char* dnp3_read_result_to_string(dnp3_read_result_t value)
{
    switch (value)
    {
        case DNP3_READ_RESULT_SUCCESS: return "Success";
        case DNP3_READ_RESULT_TOO_MANY_REQUESTS: return "TooManyRequests";
        case DNP3_READ_RESULT_BAD_RESPONSE: return "BadResponse";
        case DNP3_READ_RESULT_RESPONSE_TIMEOUT: return "ResponseTimeout";
        case DNP3_READ_RESULT_WRITE_ERROR: return "WriteError";
        case DNP3_READ_RESULT_NO_CONNECTION: return "NoConnection";
        case DNP3_READ_RESULT_SHUTDOWN: return "Shutdown";
        case DNP3_READ_RESULT_ASSOCIATION_REMOVED: return "AssociationRemoved";
        default: return "UnknownReadResult";
    }
}
 
typedef struct dnp3_read_task_callback_t
{
    
    void (*on_complete)(dnp3_read_result_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_read_task_callback_t;
 
static dnp3_read_task_callback_t dnp3_read_task_callback_init(
    void (*on_complete)(dnp3_read_result_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_read_task_callback_t result = 
    {
        .on_complete = on_complete,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
dnp3_param_error_t dnp3_master_channel_read(dnp3_master_channel_t* channel, dnp3_association_id_t association, dnp3_request_t* request, dnp3_read_task_callback_t callback);
 
typedef struct dnp3_commands_t dnp3_commands_t;
 
dnp3_commands_t* dnp3_commands_new();
 
void dnp3_commands_destroy(dnp3_commands_t* command);
 
void dnp3_commands_finish_header(dnp3_commands_t* commands);
 
void dnp3_commands_add_g12v1_u8(dnp3_commands_t* command, uint8_t idx, dnp3_g12v1_t header);
 
void dnp3_commands_add_g12v1_u16(dnp3_commands_t* command, uint16_t idx, dnp3_g12v1_t header);
 
void dnp3_commands_add_g41v1_u8(dnp3_commands_t* command, uint8_t idx, int32_t value);
 
void dnp3_commands_add_g41v1_u16(dnp3_commands_t* command, uint16_t idx, int32_t value);
 
void dnp3_commands_add_g41v2_u8(dnp3_commands_t* command, uint8_t idx, int16_t value);
 
void dnp3_commands_add_g41v2_u16(dnp3_commands_t* command, uint16_t idx, int16_t value);
 
void dnp3_commands_add_g41v3_u8(dnp3_commands_t* command, uint8_t idx, float value);
 
void dnp3_commands_add_g41v3_u16(dnp3_commands_t* commands, uint16_t idx, float value);
 
void dnp3_commands_add_g41v4_u8(dnp3_commands_t* commands, uint8_t idx, double value);
 
void dnp3_commands_add_g41v4_u16(dnp3_commands_t* commands, 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 "DirectOperate";
        case DNP3_COMMAND_MODE_SELECT_BEFORE_OPERATE: return "SelectBeforeOperate";
        default: return "UnknownCommandMode";
    }
}
 
typedef enum dnp3_command_result_t
{
    DNP3_COMMAND_RESULT_SUCCESS = 0,
    DNP3_COMMAND_RESULT_BAD_STATUS = 1,
    DNP3_COMMAND_RESULT_HEADER_MISMATCH = 2,
    DNP3_COMMAND_RESULT_TOO_MANY_REQUESTS = 3,
    DNP3_COMMAND_RESULT_BAD_RESPONSE = 4,
    DNP3_COMMAND_RESULT_RESPONSE_TIMEOUT = 5,
    DNP3_COMMAND_RESULT_WRITE_ERROR = 6,
    DNP3_COMMAND_RESULT_NO_CONNECTION = 7,
    DNP3_COMMAND_RESULT_SHUTDOWN = 8,
    DNP3_COMMAND_RESULT_ASSOCIATION_REMOVED = 9,
} dnp3_command_result_t;
 
static const char* dnp3_command_result_to_string(dnp3_command_result_t value)
{
    switch (value)
    {
        case DNP3_COMMAND_RESULT_SUCCESS: return "Success";
        case DNP3_COMMAND_RESULT_BAD_STATUS: return "BadStatus";
        case DNP3_COMMAND_RESULT_HEADER_MISMATCH: return "HeaderMismatch";
        case DNP3_COMMAND_RESULT_TOO_MANY_REQUESTS: return "TooManyRequests";
        case DNP3_COMMAND_RESULT_BAD_RESPONSE: return "BadResponse";
        case DNP3_COMMAND_RESULT_RESPONSE_TIMEOUT: return "ResponseTimeout";
        case DNP3_COMMAND_RESULT_WRITE_ERROR: return "WriteError";
        case DNP3_COMMAND_RESULT_NO_CONNECTION: return "NoConnection";
        case DNP3_COMMAND_RESULT_SHUTDOWN: return "Shutdown";
        case DNP3_COMMAND_RESULT_ASSOCIATION_REMOVED: return "AssociationRemoved";
        default: return "UnknownCommandResult";
    }
}
 
typedef struct dnp3_command_task_callback_t
{
    
    void (*on_complete)(dnp3_command_result_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_command_task_callback_t;
 
static dnp3_command_task_callback_t dnp3_command_task_callback_init(
    void (*on_complete)(dnp3_command_result_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_command_task_callback_t result = 
    {
        .on_complete = on_complete,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
dnp3_param_error_t dnp3_master_channel_operate(dnp3_master_channel_t* channel, dnp3_association_id_t association, dnp3_command_mode_t mode, dnp3_commands_t* command, dnp3_command_task_callback_t callback);
 
typedef enum dnp3_time_sync_mode_t
{
    DNP3_TIME_SYNC_MODE_LAN = 0,
    DNP3_TIME_SYNC_MODE_NON_LAN = 1,
} dnp3_time_sync_mode_t;
 
static const char* dnp3_time_sync_mode_to_string(dnp3_time_sync_mode_t value)
{
    switch (value)
    {
        case DNP3_TIME_SYNC_MODE_LAN: return "Lan";
        case DNP3_TIME_SYNC_MODE_NON_LAN: return "NonLan";
        default: return "UnknownTimeSyncMode";
    }
}
 
typedef enum dnp3_time_sync_result_t
{
    DNP3_TIME_SYNC_RESULT_SUCCESS = 0,
    DNP3_TIME_SYNC_RESULT_CLOCK_ROLLBACK = 1,
    DNP3_TIME_SYNC_RESULT_SYSTEM_TIME_NOT_UNIX = 2,
    DNP3_TIME_SYNC_RESULT_BAD_OUTSTATION_TIME_DELAY = 3,
    DNP3_TIME_SYNC_RESULT_OVERFLOW = 4,
    DNP3_TIME_SYNC_RESULT_STILL_NEEDS_TIME = 5,
    DNP3_TIME_SYNC_RESULT_SYSTEM_TIME_NOT_AVAILABLE = 6,
    DNP3_TIME_SYNC_RESULT_IIN_ERROR = 7,
    DNP3_TIME_SYNC_RESULT_TOO_MANY_REQUESTS = 8,
    DNP3_TIME_SYNC_RESULT_BAD_RESPONSE = 9,
    DNP3_TIME_SYNC_RESULT_RESPONSE_TIMEOUT = 10,
    DNP3_TIME_SYNC_RESULT_WRITE_ERROR = 11,
    DNP3_TIME_SYNC_RESULT_NO_CONNECTION = 12,
    DNP3_TIME_SYNC_RESULT_SHUTDOWN = 13,
    DNP3_TIME_SYNC_RESULT_ASSOCIATION_REMOVED = 14,
} dnp3_time_sync_result_t;
 
static const char* dnp3_time_sync_result_to_string(dnp3_time_sync_result_t value)
{
    switch (value)
    {
        case DNP3_TIME_SYNC_RESULT_SUCCESS: return "Success";
        case DNP3_TIME_SYNC_RESULT_CLOCK_ROLLBACK: return "ClockRollback";
        case DNP3_TIME_SYNC_RESULT_SYSTEM_TIME_NOT_UNIX: return "SystemTimeNotUnix";
        case DNP3_TIME_SYNC_RESULT_BAD_OUTSTATION_TIME_DELAY: return "BadOutstationTimeDelay";
        case DNP3_TIME_SYNC_RESULT_OVERFLOW: return "Overflow";
        case DNP3_TIME_SYNC_RESULT_STILL_NEEDS_TIME: return "StillNeedsTime";
        case DNP3_TIME_SYNC_RESULT_SYSTEM_TIME_NOT_AVAILABLE: return "SystemTimeNotAvailable";
        case DNP3_TIME_SYNC_RESULT_IIN_ERROR: return "IinError";
        case DNP3_TIME_SYNC_RESULT_TOO_MANY_REQUESTS: return "TooManyRequests";
        case DNP3_TIME_SYNC_RESULT_BAD_RESPONSE: return "BadResponse";
        case DNP3_TIME_SYNC_RESULT_RESPONSE_TIMEOUT: return "ResponseTimeout";
        case DNP3_TIME_SYNC_RESULT_WRITE_ERROR: return "WriteError";
        case DNP3_TIME_SYNC_RESULT_NO_CONNECTION: return "NoConnection";
        case DNP3_TIME_SYNC_RESULT_SHUTDOWN: return "Shutdown";
        case DNP3_TIME_SYNC_RESULT_ASSOCIATION_REMOVED: return "AssociationRemoved";
        default: return "UnknownTimeSyncResult";
    }
}
 
typedef struct dnp3_time_sync_task_callback_t
{
    
    void (*on_complete)(dnp3_time_sync_result_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_time_sync_task_callback_t;
 
static dnp3_time_sync_task_callback_t dnp3_time_sync_task_callback_init(
    void (*on_complete)(dnp3_time_sync_result_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_time_sync_task_callback_t result = 
    {
        .on_complete = on_complete,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
dnp3_param_error_t dnp3_master_channel_sync_time(dnp3_master_channel_t* channel, dnp3_association_id_t association, dnp3_time_sync_mode_t mode, dnp3_time_sync_task_callback_t callback);
 
typedef enum dnp3_restart_error_t
{
    DNP3_RESTART_ERROR_OK = 0,
    DNP3_RESTART_ERROR_TOO_MANY_REQUESTS = 1,
    DNP3_RESTART_ERROR_BAD_RESPONSE = 2,
    DNP3_RESTART_ERROR_RESPONSE_TIMEOUT = 3,
    DNP3_RESTART_ERROR_WRITE_ERROR = 4,
    DNP3_RESTART_ERROR_NO_CONNECTION = 5,
    DNP3_RESTART_ERROR_SHUTDOWN = 6,
    DNP3_RESTART_ERROR_ASSOCIATION_REMOVED = 7,
} dnp3_restart_error_t;
 
static const char* dnp3_restart_error_to_string(dnp3_restart_error_t value)
{
    switch (value)
    {
        case DNP3_RESTART_ERROR_OK: return "Ok";
        case DNP3_RESTART_ERROR_TOO_MANY_REQUESTS: return "TooManyRequests";
        case DNP3_RESTART_ERROR_BAD_RESPONSE: return "BadResponse";
        case DNP3_RESTART_ERROR_RESPONSE_TIMEOUT: return "ResponseTimeout";
        case DNP3_RESTART_ERROR_WRITE_ERROR: return "WriteError";
        case DNP3_RESTART_ERROR_NO_CONNECTION: return "NoConnection";
        case DNP3_RESTART_ERROR_SHUTDOWN: return "Shutdown";
        case DNP3_RESTART_ERROR_ASSOCIATION_REMOVED: return "AssociationRemoved";
        default: return "UnknownRestartError";
    }
}
 
typedef struct dnp3_restart_result_t dnp3_restart_result_t;
 
typedef struct dnp3_restart_result_t
{
    dnp3_restart_error_t error;
    uint64_t delay;
} dnp3_restart_result_t;
 
static dnp3_restart_result_t dnp3_restart_result_init(dnp3_restart_error_t error, uint64_t delay)
{
    return (dnp3_restart_result_t)
    {
        .error = error,
        .delay = delay,
    };
}
 
typedef struct dnp3_restart_task_callback_t
{
    
    void (*on_complete)(dnp3_restart_result_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_restart_task_callback_t;
 
static dnp3_restart_task_callback_t dnp3_restart_task_callback_init(
    void (*on_complete)(dnp3_restart_result_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_restart_task_callback_t result = 
    {
        .on_complete = on_complete,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
dnp3_param_error_t dnp3_master_channel_cold_restart(dnp3_master_channel_t* channel, dnp3_association_id_t association, dnp3_restart_task_callback_t callback);
 
dnp3_param_error_t dnp3_master_channel_warm_restart(dnp3_master_channel_t* channel, dnp3_association_id_t association, dnp3_restart_task_callback_t callback);
 
typedef enum dnp3_link_status_result_t
{
    DNP3_LINK_STATUS_RESULT_SUCCESS = 0,
    DNP3_LINK_STATUS_RESULT_UNEXPECTED_RESPONSE = 1,
    DNP3_LINK_STATUS_RESULT_TASK_ERROR = 2,
} dnp3_link_status_result_t;
 
static const char* dnp3_link_status_result_to_string(dnp3_link_status_result_t value)
{
    switch (value)
    {
        case DNP3_LINK_STATUS_RESULT_SUCCESS: return "Success";
        case DNP3_LINK_STATUS_RESULT_UNEXPECTED_RESPONSE: return "UnexpectedResponse";
        case DNP3_LINK_STATUS_RESULT_TASK_ERROR: return "TaskError";
        default: return "UnknownLinkStatusResult";
    }
}
 
typedef struct dnp3_link_status_callback_t
{
    
    void (*on_complete)(dnp3_link_status_result_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_link_status_callback_t;
 
static dnp3_link_status_callback_t dnp3_link_status_callback_init(
    void (*on_complete)(dnp3_link_status_result_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_link_status_callback_t result = 
    {
        .on_complete = on_complete,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
dnp3_param_error_t dnp3_master_channel_check_link_status(dnp3_master_channel_t* channel, dnp3_association_id_t association, dnp3_link_status_callback_t callback);
 
 
typedef struct dnp3_database_t dnp3_database_t;
 
typedef enum dnp3_event_class_t
{
    DNP3_EVENT_CLASS_NONE = 0,
    DNP3_EVENT_CLASS_CLASS1 = 1,
    DNP3_EVENT_CLASS_CLASS2 = 2,
    DNP3_EVENT_CLASS_CLASS3 = 3,
} dnp3_event_class_t;
 
static const char* dnp3_event_class_to_string(dnp3_event_class_t value)
{
    switch (value)
    {
        case DNP3_EVENT_CLASS_NONE: return "None";
        case DNP3_EVENT_CLASS_CLASS1: return "Class1";
        case DNP3_EVENT_CLASS_CLASS2: return "Class2";
        case DNP3_EVENT_CLASS_CLASS3: return "Class3";
        default: return "UnknownEventClass";
    }
}
 
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 "UnknownEventMode";
    }
}
 
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_init()
{
    return (dnp3_update_options_t)
    {
        .update_static = true,
        .event_mode = DNP3_EVENT_MODE_DETECT,
    };
}
 
typedef enum dnp3_static_binary_variation_t
{
    DNP3_STATIC_BINARY_VARIATION_GROUP1_VAR1 = 0,
    DNP3_STATIC_BINARY_VARIATION_GROUP1_VAR2 = 1,
} dnp3_static_binary_variation_t;
 
static const char* dnp3_static_binary_variation_to_string(dnp3_static_binary_variation_t value)
{
    switch (value)
    {
        case DNP3_STATIC_BINARY_VARIATION_GROUP1_VAR1: return "Group1Var1";
        case DNP3_STATIC_BINARY_VARIATION_GROUP1_VAR2: return "Group1Var2";
        default: return "UnknownStaticBinaryVariation";
    }
}
 
typedef enum dnp3_event_binary_variation_t
{
    DNP3_EVENT_BINARY_VARIATION_GROUP2_VAR1 = 0,
    DNP3_EVENT_BINARY_VARIATION_GROUP2_VAR2 = 1,
    DNP3_EVENT_BINARY_VARIATION_GROUP2_VAR3 = 2,
} dnp3_event_binary_variation_t;
 
static const char* dnp3_event_binary_variation_to_string(dnp3_event_binary_variation_t value)
{
    switch (value)
    {
        case DNP3_EVENT_BINARY_VARIATION_GROUP2_VAR1: return "Group2Var1";
        case DNP3_EVENT_BINARY_VARIATION_GROUP2_VAR2: return "Group2Var2";
        case DNP3_EVENT_BINARY_VARIATION_GROUP2_VAR3: return "Group2Var3";
        default: return "UnknownEventBinaryVariation";
    }
}
 
typedef struct dnp3_binary_config_t dnp3_binary_config_t;
 
typedef struct dnp3_binary_config_t
{
    dnp3_static_binary_variation_t static_variation;
    dnp3_event_binary_variation_t event_variation;
} dnp3_binary_config_t;
 
static dnp3_binary_config_t dnp3_binary_config_init()
{
    return (dnp3_binary_config_t)
    {
        .static_variation = DNP3_STATIC_BINARY_VARIATION_GROUP1_VAR1,
        .event_variation = DNP3_EVENT_BINARY_VARIATION_GROUP2_VAR1,
    };
}
 
bool dnp3_database_add_binary(dnp3_database_t* db, uint16_t index, dnp3_event_class_t point_class, dnp3_binary_config_t config);
 
bool dnp3_database_remove_binary(dnp3_database_t* db, uint16_t index);
 
bool dnp3_database_update_binary(dnp3_database_t* db, dnp3_binary_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_binary(dnp3_database_t* db, uint16_t index, dnp3_binary_t* out);
 
typedef enum dnp3_static_double_bit_binary_variation_t
{
    DNP3_STATIC_DOUBLE_BIT_BINARY_VARIATION_GROUP3_VAR1 = 0,
    DNP3_STATIC_DOUBLE_BIT_BINARY_VARIATION_GROUP3_VAR2 = 1,
} dnp3_static_double_bit_binary_variation_t;
 
static const char* dnp3_static_double_bit_binary_variation_to_string(dnp3_static_double_bit_binary_variation_t value)
{
    switch (value)
    {
        case DNP3_STATIC_DOUBLE_BIT_BINARY_VARIATION_GROUP3_VAR1: return "Group3Var1";
        case DNP3_STATIC_DOUBLE_BIT_BINARY_VARIATION_GROUP3_VAR2: return "Group3Var2";
        default: return "UnknownStaticDoubleBitBinaryVariation";
    }
}
 
typedef enum dnp3_event_double_bit_binary_variation_t
{
    DNP3_EVENT_DOUBLE_BIT_BINARY_VARIATION_GROUP4_VAR1 = 0,
    DNP3_EVENT_DOUBLE_BIT_BINARY_VARIATION_GROUP4_VAR2 = 1,
    DNP3_EVENT_DOUBLE_BIT_BINARY_VARIATION_GROUP4_VAR3 = 2,
} dnp3_event_double_bit_binary_variation_t;
 
static const char* dnp3_event_double_bit_binary_variation_to_string(dnp3_event_double_bit_binary_variation_t value)
{
    switch (value)
    {
        case DNP3_EVENT_DOUBLE_BIT_BINARY_VARIATION_GROUP4_VAR1: return "Group4Var1";
        case DNP3_EVENT_DOUBLE_BIT_BINARY_VARIATION_GROUP4_VAR2: return "Group4Var2";
        case DNP3_EVENT_DOUBLE_BIT_BINARY_VARIATION_GROUP4_VAR3: return "Group4Var3";
        default: return "UnknownEventDoubleBitBinaryVariation";
    }
}
 
typedef struct dnp3_double_bit_binary_config_t dnp3_double_bit_binary_config_t;
 
typedef struct dnp3_double_bit_binary_config_t
{
    dnp3_static_double_bit_binary_variation_t static_variation;
    dnp3_event_double_bit_binary_variation_t event_variation;
} dnp3_double_bit_binary_config_t;
 
static dnp3_double_bit_binary_config_t dnp3_double_bit_binary_config_init()
{
    return (dnp3_double_bit_binary_config_t)
    {
        .static_variation = DNP3_STATIC_DOUBLE_BIT_BINARY_VARIATION_GROUP3_VAR1,
        .event_variation = DNP3_EVENT_DOUBLE_BIT_BINARY_VARIATION_GROUP4_VAR1,
    };
}
 
bool dnp3_database_add_double_bit_binary(dnp3_database_t* db, uint16_t index, dnp3_event_class_t point_class, dnp3_double_bit_binary_config_t config);
 
bool dnp3_database_remove_double_bit_binary(dnp3_database_t* db, uint16_t index);
 
bool dnp3_database_update_double_bit_binary(dnp3_database_t* db, dnp3_double_bit_binary_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_double_bit_binary(dnp3_database_t* db, uint16_t index, dnp3_double_bit_binary_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 "Group10Var1";
        case DNP3_STATIC_BINARY_OUTPUT_STATUS_VARIATION_GROUP10_VAR2: return "Group10Var2";
        default: return "UnknownStaticBinaryOutputStatusVariation";
    }
}
 
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 "Group11Var1";
        case DNP3_EVENT_BINARY_OUTPUT_STATUS_VARIATION_GROUP11_VAR2: return "Group11Var2";
        default: return "UnknownEventBinaryOutputStatusVariation";
    }
}
 
typedef struct dnp3_binary_output_status_config_t dnp3_binary_output_status_config_t;
 
typedef struct dnp3_binary_output_status_config_t
{
    dnp3_static_binary_output_status_variation_t static_variation;
    dnp3_event_binary_output_status_variation_t event_variation;
} dnp3_binary_output_status_config_t;
 
static dnp3_binary_output_status_config_t dnp3_binary_output_status_config_init()
{
    return (dnp3_binary_output_status_config_t)
    {
        .static_variation = DNP3_STATIC_BINARY_OUTPUT_STATUS_VARIATION_GROUP10_VAR1,
        .event_variation = DNP3_EVENT_BINARY_OUTPUT_STATUS_VARIATION_GROUP11_VAR2,
    };
}
 
bool dnp3_database_add_binary_output_status(dnp3_database_t* db, 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* db, uint16_t index);
 
bool dnp3_database_update_binary_output_status(dnp3_database_t* db, dnp3_binary_output_status_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_binary_output_status(dnp3_database_t* db, 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 "Group20Var1";
        case DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR2: return "Group20Var2";
        case DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR5: return "Group20Var5";
        case DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR6: return "Group20Var6";
        default: return "UnknownStaticCounterVariation";
    }
}
 
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 "Group22Var1";
        case DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR2: return "Group22Var2";
        case DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR5: return "Group22Var5";
        case DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR6: return "Group22Var6";
        default: return "UnknownEventCounterVariation";
    }
}
 
typedef struct dnp3_counter_config_t dnp3_counter_config_t;
 
typedef struct dnp3_counter_config_t
{
    dnp3_static_counter_variation_t static_variation;
    dnp3_event_counter_variation_t event_variation;
    uint32_t deadband;
} dnp3_counter_config_t;
 
static dnp3_counter_config_t dnp3_counter_config_init()
{
    return (dnp3_counter_config_t)
    {
        .static_variation = DNP3_STATIC_COUNTER_VARIATION_GROUP20_VAR1,
        .event_variation = DNP3_EVENT_COUNTER_VARIATION_GROUP22_VAR1,
        .deadband = 0,
    };
}
 
bool dnp3_database_add_counter(dnp3_database_t* db, uint16_t index, dnp3_event_class_t point_class, dnp3_counter_config_t config);
 
bool dnp3_database_remove_counter(dnp3_database_t* db, uint16_t index);
 
bool dnp3_database_update_counter(dnp3_database_t* db, dnp3_counter_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_counter(dnp3_database_t* db, 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 "Group21Var1";
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR2: return "Group21Var2";
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR5: return "Group21Var5";
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR6: return "Group21Var6";
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR9: return "Group21Var9";
        case DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR10: return "Group21Var10";
        default: return "UnknownStaticFrozenCounterVariation";
    }
}
 
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 "Group23Var1";
        case DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR2: return "Group23Var2";
        case DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR5: return "Group23Var5";
        case DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR6: return "Group23Var6";
        default: return "UnknownEventFrozenCounterVariation";
    }
}
 
typedef struct dnp3_frozen_counter_config_t dnp3_frozen_counter_config_t;
 
typedef struct dnp3_frozen_counter_config_t
{
    dnp3_static_frozen_counter_variation_t static_variation;
    dnp3_event_frozen_counter_variation_t event_variation;
    uint32_t deadband;
} dnp3_frozen_counter_config_t;
 
static dnp3_frozen_counter_config_t dnp3_frozen_counter_config_init()
{
    return (dnp3_frozen_counter_config_t)
    {
        .static_variation = DNP3_STATIC_FROZEN_COUNTER_VARIATION_GROUP21_VAR1,
        .event_variation = DNP3_EVENT_FROZEN_COUNTER_VARIATION_GROUP23_VAR1,
        .deadband = 0,
    };
}
 
bool dnp3_database_add_frozen_counter(dnp3_database_t* db, uint16_t index, dnp3_event_class_t point_class, dnp3_frozen_counter_config_t config);
 
bool dnp3_database_remove_frozen_counter(dnp3_database_t* db, uint16_t index);
 
bool dnp3_database_update_frozen_counter(dnp3_database_t* db, dnp3_frozen_counter_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_frozen_counter(dnp3_database_t* db, uint16_t index, dnp3_frozen_counter_t* out);
 
typedef enum dnp3_static_analog_variation_t
{
    DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR1 = 0,
    DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR2 = 1,
    DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR3 = 2,
    DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR4 = 3,
    DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR5 = 4,
    DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR6 = 5,
} dnp3_static_analog_variation_t;
 
static const char* dnp3_static_analog_variation_to_string(dnp3_static_analog_variation_t value)
{
    switch (value)
    {
        case DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR1: return "Group30Var1";
        case DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR2: return "Group30Var2";
        case DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR3: return "Group30Var3";
        case DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR4: return "Group30Var4";
        case DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR5: return "Group30Var5";
        case DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR6: return "Group30Var6";
        default: return "UnknownStaticAnalogVariation";
    }
}
 
typedef enum dnp3_event_analog_variation_t
{
    DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR1 = 0,
    DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR2 = 1,
    DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR3 = 2,
    DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR4 = 3,
    DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR5 = 4,
    DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR6 = 5,
    DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR7 = 6,
    DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR8 = 7,
} dnp3_event_analog_variation_t;
 
static const char* dnp3_event_analog_variation_to_string(dnp3_event_analog_variation_t value)
{
    switch (value)
    {
        case DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR1: return "Group32Var1";
        case DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR2: return "Group32Var2";
        case DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR3: return "Group32Var3";
        case DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR4: return "Group32Var4";
        case DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR5: return "Group32Var5";
        case DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR6: return "Group32Var6";
        case DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR7: return "Group32Var7";
        case DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR8: return "Group32Var8";
        default: return "UnknownEventAnalogVariation";
    }
}
 
typedef struct dnp3_analog_config_t dnp3_analog_config_t;
 
typedef struct dnp3_analog_config_t
{
    dnp3_static_analog_variation_t static_variation;
    dnp3_event_analog_variation_t event_variation;
    double deadband;
} dnp3_analog_config_t;
 
static dnp3_analog_config_t dnp3_analog_config_init()
{
    return (dnp3_analog_config_t)
    {
        .static_variation = DNP3_STATIC_ANALOG_VARIATION_GROUP30_VAR1,
        .event_variation = DNP3_EVENT_ANALOG_VARIATION_GROUP32_VAR1,
        .deadband = 0,
    };
}
 
bool dnp3_database_add_analog(dnp3_database_t* db, uint16_t index, dnp3_event_class_t point_class, dnp3_analog_config_t config);
 
bool dnp3_database_remove_analog(dnp3_database_t* db, uint16_t index);
 
bool dnp3_database_update_analog(dnp3_database_t* db, dnp3_analog_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_analog(dnp3_database_t* db, uint16_t index, dnp3_analog_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 "Group40Var1";
        case DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR2: return "Group40Var2";
        case DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR3: return "Group40Var3";
        case DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR4: return "Group40Var4";
        default: return "UnknownStaticAnalogOutputStatusVariation";
    }
}
 
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 "Group42Var1";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR2: return "Group42Var2";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR3: return "Group42Var3";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR4: return "Group42Var4";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR5: return "Group42Var5";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR6: return "Group42Var6";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR7: return "Group42Var7";
        case DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR8: return "Group42Var8";
        default: return "UnknownEventAnalogOutputStatusVariation";
    }
}
 
typedef struct dnp3_analog_output_status_config_t dnp3_analog_output_status_config_t;
 
typedef struct dnp3_analog_output_status_config_t
{
    dnp3_static_analog_output_status_variation_t static_variation;
    dnp3_event_analog_output_status_variation_t event_variation;
    double deadband;
} dnp3_analog_output_status_config_t;
 
static dnp3_analog_output_status_config_t dnp3_analog_output_status_config_init()
{
    return (dnp3_analog_output_status_config_t)
    {
        .static_variation = DNP3_STATIC_ANALOG_OUTPUT_STATUS_VARIATION_GROUP40_VAR1,
        .event_variation = DNP3_EVENT_ANALOG_OUTPUT_STATUS_VARIATION_GROUP42_VAR1,
        .deadband = 0,
    };
}
 
bool dnp3_database_add_analog_output_status(dnp3_database_t* db, 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* db, uint16_t index);
 
bool dnp3_database_update_analog_output_status(dnp3_database_t* db, dnp3_analog_output_status_t value, dnp3_update_options_t options);
 
dnp3_param_error_t dnp3_database_get_analog_output_status(dnp3_database_t* db, 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_new();
 
void dnp3_octet_string_destroy(dnp3_octet_string_value_t* octet_string);
 
void dnp3_octet_string_add(dnp3_octet_string_value_t* octet_string, uint8_t value);
 
 
bool dnp3_database_add_octet_string(dnp3_database_t* db, uint16_t index, dnp3_event_class_t point_class);
 
bool dnp3_database_remove_octet_string(dnp3_database_t* db, uint16_t index);
 
bool dnp3_database_update_octet_string(dnp3_database_t* db, uint16_t index, dnp3_octet_string_value_t* value, dnp3_update_options_t options);
 
 
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_strings;
} dnp3_class_zero_config_t;
 
static dnp3_class_zero_config_t dnp3_class_zero_config_init()
{
    return (dnp3_class_zero_config_t)
    {
        .binary = true,
        .double_bit_binary = true,
        .binary_output_status = true,
        .counter = true,
        .frozen_counter = true,
        .analog = true,
        .analog_output_status = true,
        .octet_strings = false,
    };
}
 
typedef struct dnp3_outstation_features_t dnp3_outstation_features_t;
 
typedef struct dnp3_outstation_features_t
{
    bool self_address;
    bool broadcast;
    bool unsolicited;
} dnp3_outstation_features_t;
 
static dnp3_outstation_features_t dnp3_outstation_features_init()
{
    return (dnp3_outstation_features_t)
    {
        .self_address = false,
        .broadcast = true,
        .unsolicited = true,
    };
}
 
typedef struct dnp3_outstation_config_t dnp3_outstation_config_t;
 
typedef struct dnp3_outstation_config_t
{
    uint16_t outstation_address;
    uint16_t master_address;
    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)
{
    return (dnp3_outstation_config_t)
    {
        .outstation_address = outstation_address,
        .master_address = master_address,
        .solicited_buffer_size = 2048,
        .unsolicited_buffer_size = 2048,
        .rx_buffer_size = 2048,
        .decode_level = dnp3_decode_level_init(),
        .confirm_timeout = 5000,
        .select_timeout = 5000,
        .features = dnp3_outstation_features_init(),
        .max_unsolicited_retries = 4294967295,
        .unsolicited_retry_delay = 5000,
        .keep_alive_timeout = 60000,
        .max_read_request_headers = 64,
        .max_controls_per_request = 64,
        .class_zero = dnp3_class_zero_config_init(),
    };
}
 
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)
{
    return (dnp3_event_buffer_config_t)
    {
        .max_binary = max_binary,
        .max_double_bit_binary = max_double_bit_binary,
        .max_binary_output_status = max_binary_output_status,
        .max_counter = max_counter,
        .max_frozen_counter = max_frozen_counter,
        .max_analog = max_analog,
        .max_analog_output_status = max_analog_output_status,
        .max_octet_string = max_octet_string,
    };
}
 
dnp3_event_buffer_config_t dnp3_event_buffer_config_all_types(uint16_t max);
 
dnp3_event_buffer_config_t dnp3_event_buffer_config_no_events();
 
 
typedef enum dnp3_restart_delay_type_t
{
    DNP3_RESTART_DELAY_TYPE_NOT_SUPPORTED = 0,
    DNP3_RESTART_DELAY_TYPE_SECONDS = 1,
    DNP3_RESTART_DELAY_TYPE_MILLISECONDS = 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 "NotSupported";
        case DNP3_RESTART_DELAY_TYPE_SECONDS: return "Seconds";
        case DNP3_RESTART_DELAY_TYPE_MILLISECONDS: return "Milliseconds";
        default: return "UnknownRestartDelayType";
    }
}
 
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()
{
    return (dnp3_application_iin_t)
    {
        .need_time = false,
        .local_control = false,
        .device_trouble = false,
        .config_corrupt = false,
    };
}
 
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_init(dnp3_restart_delay_type_t restart_type, uint16_t value)
{
    return (dnp3_restart_delay_t)
    {
        .restart_type = restart_type,
        .value = value,
    };
}
 
dnp3_restart_delay_t dnp3_restart_delay_not_supported();
 
dnp3_restart_delay_t dnp3_restart_delay_seconds(uint16_t value);
 
dnp3_restart_delay_t dnp3_restart_delay_millis(uint16_t value);
 
 
typedef enum dnp3_write_time_result_t
{
    DNP3_WRITE_TIME_RESULT_NOT_SUPPORTED = 0,
    DNP3_WRITE_TIME_RESULT_INVALID_VALUE = 1,
    DNP3_WRITE_TIME_RESULT_OK = 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_NOT_SUPPORTED: return "NotSupported";
        case DNP3_WRITE_TIME_RESULT_INVALID_VALUE: return "InvalidValue";
        case DNP3_WRITE_TIME_RESULT_OK: return "Ok";
        default: return "UnknownWriteTimeResult";
    }
}
 
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 "ImmediateFreeze";
        case DNP3_FREEZE_TYPE_FREEZE_AND_CLEAR: return "FreezeAndClear";
        default: return "UnknownFreezeType";
    }
}
 
typedef enum dnp3_freeze_result_t
{
    DNP3_FREEZE_RESULT_SUCCESS = 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_SUCCESS: return "Success";
        case DNP3_FREEZE_RESULT_PARAMETER_ERROR: return "ParameterError";
        case DNP3_FREEZE_RESULT_NOT_SUPPORTED: return "NotSupported";
        default: return "UnknownFreezeResult";
    }
}
 
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_t*, void*);
    
    dnp3_freeze_result_t (*freeze_counters_range)(uint16_t, uint16_t, dnp3_freeze_type_t, dnp3_database_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_outstation_application_t;
 
static dnp3_outstation_application_t dnp3_outstation_application_init(
    uint16_t (*get_processing_delay_ms)(void*),
    dnp3_write_time_result_t (*write_absolute_time)(uint64_t, void*),
    dnp3_application_iin_t (*get_application_iin)(void*),
    dnp3_restart_delay_t (*cold_restart)(void*),
    dnp3_restart_delay_t (*warm_restart)(void*),
    dnp3_freeze_result_t (*freeze_counters_all)(dnp3_freeze_type_t, dnp3_database_t*, void*),
    dnp3_freeze_result_t (*freeze_counters_range)(uint16_t, uint16_t, dnp3_freeze_type_t, dnp3_database_t*, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_outstation_application_t result = 
    {
        .get_processing_delay_ms = get_processing_delay_ms,
        .write_absolute_time = write_absolute_time,
        .get_application_iin = get_application_iin,
        .cold_restart = cold_restart,
        .warm_restart = warm_restart,
        .freeze_counters_all = freeze_counters_all,
        .freeze_counters_range = freeze_counters_range,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
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 "DirectOperate";
        case DNP3_FUNCTION_CODE_DIRECT_OPERATE_NO_RESPONSE: return "DirectOperateNoResponse";
        case DNP3_FUNCTION_CODE_IMMEDIATE_FREEZE: return "ImmediateFreeze";
        case DNP3_FUNCTION_CODE_IMMEDIATE_FREEZE_NO_RESPONSE: return "ImmediateFreezeNoResponse";
        case DNP3_FUNCTION_CODE_FREEZE_CLEAR: return "FreezeClear";
        case DNP3_FUNCTION_CODE_FREEZE_CLEAR_NO_RESPONSE: return "FreezeClearNoResponse";
        case DNP3_FUNCTION_CODE_FREEZE_AT_TIME: return "FreezeAtTime";
        case DNP3_FUNCTION_CODE_FREEZE_AT_TIME_NO_RESPONSE: return "FreezeAtTimeNoResponse";
        case DNP3_FUNCTION_CODE_COLD_RESTART: return "ColdRestart";
        case DNP3_FUNCTION_CODE_WARM_RESTART: return "WarmRestart";
        case DNP3_FUNCTION_CODE_INITIALIZE_DATA: return "InitializeData";
        case DNP3_FUNCTION_CODE_INITIALIZE_APPLICATION: return "InitializeApplication";
        case DNP3_FUNCTION_CODE_START_APPLICATION: return "StartApplication";
        case DNP3_FUNCTION_CODE_STOP_APPLICATION: return "StopApplication";
        case DNP3_FUNCTION_CODE_SAVE_CONFIGURATION: return "SaveConfiguration";
        case DNP3_FUNCTION_CODE_ENABLE_UNSOLICITED: return "EnableUnsolicited";
        case DNP3_FUNCTION_CODE_DISABLE_UNSOLICITED: return "DisableUnsolicited";
        case DNP3_FUNCTION_CODE_ASSIGN_CLASS: return "AssignClass";
        case DNP3_FUNCTION_CODE_DELAY_MEASURE: return "DelayMeasure";
        case DNP3_FUNCTION_CODE_RECORD_CURRENT_TIME: return "RecordCurrentTime";
        case DNP3_FUNCTION_CODE_OPEN_FILE: return "OpenFile";
        case DNP3_FUNCTION_CODE_CLOSE_FILE: return "CloseFile";
        case DNP3_FUNCTION_CODE_DELETE_FILE: return "DeleteFile";
        case DNP3_FUNCTION_CODE_GET_FILE_INFO: return "GetFileInfo";
        case DNP3_FUNCTION_CODE_AUTHENTICATE_FILE: return "AuthenticateFile";
        case DNP3_FUNCTION_CODE_ABORT_FILE: return "AbortFile";
        case DNP3_FUNCTION_CODE_RESPONSE: return "Response";
        case DNP3_FUNCTION_CODE_UNSOLICITED_RESPONSE: return "UnsolicitedResponse";
        default: return "UnknownFunctionCode";
    }
}
 
typedef struct dnp3_request_header_t dnp3_request_header_t;
 
typedef struct dnp3_request_header_t
{
    dnp3_control_t control;
    dnp3_function_code_t function;
} dnp3_request_header_t;
 
static dnp3_request_header_t dnp3_request_header_init(dnp3_control_t control, dnp3_function_code_t function)
{
    return (dnp3_request_header_t)
    {
        .control = control,
        .function = function,
    };
}
 
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 "IgnoredByConfiguration";
        case DNP3_BROADCAST_ACTION_BAD_OBJECT_HEADERS: return "BadObjectHeaders";
        case DNP3_BROADCAST_ACTION_UNSUPPORTED_FUNCTION: return "UnsupportedFunction";
        default: return "UnknownBroadcastAction";
    }
}
 
typedef struct dnp3_outstation_information_t
{
    
    void (*process_request_from_idle)(dnp3_request_header_t, void*);
    
    void (*broadcast_received)(dnp3_function_code_t, dnp3_broadcast_action_t, void*);
    
    void (*enter_solicited_confirm_wait)(uint8_t, void*);
    
    void (*solicited_confirm_timeout)(uint8_t, void*);
    
    void (*solicited_confirm_received)(uint8_t, void*);
    
    void (*solicited_confirm_wait_new_request)(void*);
    
    void (*wrong_solicited_confirm_seq)(uint8_t, uint8_t, void*);
    
    void (*unexpected_confirm)(bool, uint8_t, void*);
    
    void (*enter_unsolicited_confirm_wait)(uint8_t, void*);
    
    void (*unsolicited_confirm_timeout)(uint8_t, bool, void*);
    
    void (*unsolicited_confirmed)(uint8_t, void*);
    
    void (*clear_restart_iin)(void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_outstation_information_t;
 
static dnp3_outstation_information_t dnp3_outstation_information_init(
    void (*process_request_from_idle)(dnp3_request_header_t, void*),
    void (*broadcast_received)(dnp3_function_code_t, dnp3_broadcast_action_t, void*),
    void (*enter_solicited_confirm_wait)(uint8_t, void*),
    void (*solicited_confirm_timeout)(uint8_t, void*),
    void (*solicited_confirm_received)(uint8_t, void*),
    void (*solicited_confirm_wait_new_request)(void*),
    void (*wrong_solicited_confirm_seq)(uint8_t, uint8_t, void*),
    void (*unexpected_confirm)(bool, uint8_t, void*),
    void (*enter_unsolicited_confirm_wait)(uint8_t, void*),
    void (*unsolicited_confirm_timeout)(uint8_t, bool, void*),
    void (*unsolicited_confirmed)(uint8_t, void*),
    void (*clear_restart_iin)(void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_outstation_information_t result = 
    {
        .process_request_from_idle = process_request_from_idle,
        .broadcast_received = broadcast_received,
        .enter_solicited_confirm_wait = enter_solicited_confirm_wait,
        .solicited_confirm_timeout = solicited_confirm_timeout,
        .solicited_confirm_received = solicited_confirm_received,
        .solicited_confirm_wait_new_request = solicited_confirm_wait_new_request,
        .wrong_solicited_confirm_seq = wrong_solicited_confirm_seq,
        .unexpected_confirm = unexpected_confirm,
        .enter_unsolicited_confirm_wait = enter_unsolicited_confirm_wait,
        .unsolicited_confirm_timeout = unsolicited_confirm_timeout,
        .unsolicited_confirmed = unsolicited_confirmed,
        .clear_restart_iin = clear_restart_iin,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
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 "NoSelect";
        case DNP3_COMMAND_STATUS_FORMAT_ERROR: return "FormatError";
        case DNP3_COMMAND_STATUS_NOT_SUPPORTED: return "NotSupported";
        case DNP3_COMMAND_STATUS_ALREADY_ACTIVE: return "AlreadyActive";
        case DNP3_COMMAND_STATUS_HARDWARE_ERROR: return "HardwareError";
        case DNP3_COMMAND_STATUS_LOCAL: return "Local";
        case DNP3_COMMAND_STATUS_TOO_MANY_OPS: return "TooManyOps";
        case DNP3_COMMAND_STATUS_NOT_AUTHORIZED: return "NotAuthorized";
        case DNP3_COMMAND_STATUS_AUTOMATION_INHIBIT: return "AutomationInhibit";
        case DNP3_COMMAND_STATUS_PROCESSING_LIMITED: return "ProcessingLimited";
        case DNP3_COMMAND_STATUS_OUT_OF_RANGE: return "OutOfRange";
        case DNP3_COMMAND_STATUS_DOWNSTREAM_LOCAL: return "DownstreamLocal";
        case DNP3_COMMAND_STATUS_ALREADY_COMPLETE: return "AlreadyComplete";
        case DNP3_COMMAND_STATUS_BLOCKED: return "Blocked";
        case DNP3_COMMAND_STATUS_CANCELED: return "Canceled";
        case DNP3_COMMAND_STATUS_BLOCKED_OTHER_MASTER: return "BlockedOtherMaster";
        case DNP3_COMMAND_STATUS_DOWNSTREAM_FAIL: return "DownstreamFail";
        case DNP3_COMMAND_STATUS_NON_PARTICIPATING: return "NonParticipating";
        case DNP3_COMMAND_STATUS_UNKNOWN: return "Unknown";
        default: return "UnknownCommandStatus";
    }
}
 
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 "SelectBeforeOperate";
        case DNP3_OPERATE_TYPE_DIRECT_OPERATE: return "DirectOperate";
        case DNP3_OPERATE_TYPE_DIRECT_OPERATE_NO_ACK: return "DirectOperateNoAck";
        default: return "UnknownOperateType";
    }
}
 
typedef struct dnp3_control_handler_t
{
    
    void (*begin_fragment)(void*);
    
    void (*end_fragment)(void*);
    
    dnp3_command_status_t (*select_g12v1)(dnp3_g12v1_t, uint16_t, dnp3_database_t*, void*);
    
    dnp3_command_status_t (*operate_g12v1)(dnp3_g12v1_t, uint16_t, dnp3_operate_type_t, dnp3_database_t*, void*);
    
    dnp3_command_status_t (*select_g41v1)(int32_t, uint16_t, dnp3_database_t*, void*);
    
    dnp3_command_status_t (*operate_g41v1)(int32_t, uint16_t, dnp3_operate_type_t, dnp3_database_t*, void*);
    
    dnp3_command_status_t (*select_g41v2)(int16_t, uint16_t, dnp3_database_t*, void*);
    
    dnp3_command_status_t (*operate_g41v2)(int16_t, uint16_t, dnp3_operate_type_t, dnp3_database_t*, void*);
    
    dnp3_command_status_t (*select_g41v3)(float, uint16_t, dnp3_database_t*, void*);
    
    dnp3_command_status_t (*operate_g41v3)(float, uint16_t, dnp3_operate_type_t, dnp3_database_t*, void*);
    
    dnp3_command_status_t (*select_g41v4)(double, uint16_t, dnp3_database_t*, void*);
    
    dnp3_command_status_t (*operate_g41v4)(double, uint16_t, dnp3_operate_type_t, dnp3_database_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_control_handler_t;
 
static dnp3_control_handler_t dnp3_control_handler_init(
    void (*begin_fragment)(void*),
    void (*end_fragment)(void*),
    dnp3_command_status_t (*select_g12v1)(dnp3_g12v1_t, uint16_t, dnp3_database_t*, void*),
    dnp3_command_status_t (*operate_g12v1)(dnp3_g12v1_t, uint16_t, dnp3_operate_type_t, dnp3_database_t*, void*),
    dnp3_command_status_t (*select_g41v1)(int32_t, uint16_t, dnp3_database_t*, void*),
    dnp3_command_status_t (*operate_g41v1)(int32_t, uint16_t, dnp3_operate_type_t, dnp3_database_t*, void*),
    dnp3_command_status_t (*select_g41v2)(int16_t, uint16_t, dnp3_database_t*, void*),
    dnp3_command_status_t (*operate_g41v2)(int16_t, uint16_t, dnp3_operate_type_t, dnp3_database_t*, void*),
    dnp3_command_status_t (*select_g41v3)(float, uint16_t, dnp3_database_t*, void*),
    dnp3_command_status_t (*operate_g41v3)(float, uint16_t, dnp3_operate_type_t, dnp3_database_t*, void*),
    dnp3_command_status_t (*select_g41v4)(double, uint16_t, dnp3_database_t*, void*),
    dnp3_command_status_t (*operate_g41v4)(double, uint16_t, dnp3_operate_type_t, dnp3_database_t*, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_control_handler_t result = 
    {
        .begin_fragment = begin_fragment,
        .end_fragment = end_fragment,
        .select_g12v1 = select_g12v1,
        .operate_g12v1 = operate_g12v1,
        .select_g41v1 = select_g41v1,
        .operate_g41v1 = operate_g41v1,
        .select_g41v2 = select_g41v2,
        .operate_g41v2 = operate_g41v2,
        .select_g41v3 = select_g41v3,
        .operate_g41v3 = operate_g41v3,
        .select_g41v4 = select_g41v4,
        .operate_g41v4 = operate_g41v4,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
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 "UnknownConnectionState";
    }
}
 
typedef struct dnp3_connection_state_listener_t
{
    
    void (*on_change)(dnp3_connection_state_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_connection_state_listener_t;
 
static dnp3_connection_state_listener_t dnp3_connection_state_listener_init(
    void (*on_change)(dnp3_connection_state_t, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_connection_state_listener_t result = 
    {
        .on_change = on_change,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
typedef struct dnp3_outstation_transaction_t
{
    
    void (*execute)(dnp3_database_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} dnp3_outstation_transaction_t;
 
static dnp3_outstation_transaction_t dnp3_outstation_transaction_init(
    void (*execute)(dnp3_database_t*, void*),
    void (*on_destroy)(void* arg),
    void* ctx
)
{
    dnp3_outstation_transaction_t result = 
    {
        .execute = execute,
        .on_destroy = on_destroy,
        .ctx = ctx,
    };
    return result;
}
 
typedef struct dnp3_outstation_t dnp3_outstation_t;
 
dnp3_param_error_t dnp3_outstation_create_serial_session(dnp3_runtime_t* runtime, const char* serial_path, dnp3_serial_port_settings_t settings, dnp3_outstation_config_t config, dnp3_event_buffer_config_t event_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* outstation);
 
void dnp3_outstation_transaction(dnp3_outstation_t* outstation, dnp3_outstation_transaction_t callback);
 
dnp3_param_error_t dnp3_outstation_set_decode_level(dnp3_outstation_t* outstation, dnp3_decode_level_t level);
 
 
typedef struct dnp3_address_filter_t dnp3_address_filter_t;
 
dnp3_address_filter_t* dnp3_address_filter_any();
 
dnp3_param_error_t dnp3_address_filter_new(const char* address, dnp3_address_filter_t** out);
 
dnp3_param_error_t dnp3_address_filter_add(dnp3_address_filter_t* address_filter, const char* address);
 
void dnp3_address_filter_destroy(dnp3_address_filter_t* address_filter);
 
 
typedef struct dnp3_tcp_server_t dnp3_tcp_server_t;
 
dnp3_param_error_t dnp3_tcpserver_new(dnp3_runtime_t* runtime, dnp3_link_error_mode_t link_error_mode, const char* address, dnp3_tcp_server_t** out);
 
void dnp3_tcpserver_destroy(dnp3_tcp_server_t* server);
 
dnp3_param_error_t dnp3_tcpserver_add_outstation(dnp3_tcp_server_t* server, dnp3_outstation_config_t config, dnp3_event_buffer_config_t event_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_tcpserver_bind(dnp3_tcp_server_t* server);
 
 
#ifdef __cplusplus
}
#endif