peak_backend.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <peak_common_c/detail/peak_common_defines.h>
#include <peak/backend/peak_dll_defines.h>
 
#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201703L))
#    define PEAK_NO_DISCARD [[nodiscard]]
#    define PEAK_MAYBE_UNUSED [[maybe_unused]]
#else
#    ifdef _MSC_VER
#        define PEAK_NO_DISCARD _Check_return_
#        define PEAK_MAYBE_UNUSED
#    elif defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
#        define PEAK_NO_DISCARD __attribute__((warn_unused_result))
#        define PEAK_MAYBE_UNUSED __attribute__((unused))
#    else
#        define PEAK_NO_DISCARD
#        define PEAK_MAYBE_UNUSED
#    endif
#endif
 
 
#ifdef __cplusplus
#    include <cstddef>
#    include <cstdint>
 
extern "C" {
#else
#    include <stddef.h>
#    include <stdint.h>
#endif
 
typedef int8_t PEAK_BOOL8;

enum PEAK_ACQUISITION_START_MODE_t
{
    PEAK_ACQUISITION_START_MODE_DEFAULT = 0,
 
    PEAK_ACQUISITION_START_MODE_CUSTOM = 1000
};
typedef int32_t PEAK_ACQUISITION_START_MODE;

enum PEAK_ACQUISITION_STOP_MODE_t
{
    PEAK_ACQUISITION_STOP_MODE_DEFAULT = 0,
    PEAK_ACQUISITION_STOP_MODE_KILL,
 
    PEAK_ACQUISITION_STOP_MODE_CUSTOM = 1000
};
typedef int32_t PEAK_ACQUISITION_STOP_MODE;

enum PEAK_BUFFER_PART_TYPE_t
{
    PEAK_BUFFER_PART_TYPE_UNKNOWN = 0,
    PEAK_BUFFER_PART_TYPE_IMAGE_2D,
    PEAK_BUFFER_PART_TYPE_PLANE_BI_PLANAR_2D,
    PEAK_BUFFER_PART_TYPE_PLANE_TRI_PLANAR_2D,
    PEAK_BUFFER_PART_TYPE_PLANE_QUAD_PLANAR_2D,
    PEAK_BUFFER_PART_TYPE_IMAGE_3D,
    PEAK_BUFFER_PART_TYPE_PLANE_BI_PLANAR_3D,
    PEAK_BUFFER_PART_TYPE_PLANE_TRI_PLANAR_3D,
    PEAK_BUFFER_PART_TYPE_PLANE_QUAD_PLANAR_3D,
    PEAK_BUFFER_PART_TYPE_CONFIDENCE_MAP,
 
    PEAK_BUFFER_PART_TYPE_CUSTOM = 1000
};
typedef int32_t PEAK_BUFFER_PART_TYPE;

enum PEAK_BUFFER_PAYLOAD_TYPE_t
{
    PEAK_BUFFER_PAYLOAD_TYPE_UNKNOWN = 0,
    PEAK_BUFFER_PAYLOAD_TYPE_IMAGE,
    PEAK_BUFFER_PAYLOAD_TYPE_RAW_DATA,
    PEAK_BUFFER_PAYLOAD_TYPE_FILE,
    PEAK_BUFFER_PAYLOAD_TYPE_CHUNK,
    PEAK_BUFFER_PAYLOAD_TYPE_JPEG,
    PEAK_BUFFER_PAYLOAD_TYPE_JPEG_2000,
    PEAK_BUFFER_PAYLOAD_TYPE_H264,
    PEAK_BUFFER_PAYLOAD_TYPE_CHUNK_ONLY,
    PEAK_BUFFER_PAYLOAD_TYPE_DEVICE_SPECIFIC,
    PEAK_BUFFER_PAYLOAD_TYPE_MULTI_PART,
 
    PEAK_BUFFER_PAYLOAD_TYPE_CUSTOM = 1000
};
typedef int32_t PEAK_BUFFER_PAYLOAD_TYPE;

enum PEAK_CHARACTER_ENCODING_t
{
    PEAK_CHARACTER_ENCODING_ASCII = 0,
    PEAK_CHARACTER_ENCODING_UTF8
};
typedef int32_t PEAK_CHARACTER_ENCODING;

enum PEAK_DATA_STREAM_FLUSH_MODE_t
{
    PEAK_DATA_STREAM_FLUSH_MODE_INPUT_POOL_TO_OUTPUT_QUEUE = 0,
    PEAK_DATA_STREAM_FLUSH_MODE_DISCARD_OUTPUT_QUEUE,
    PEAK_DATA_STREAM_FLUSH_MODE_ALL_TO_INPUT_POOL,
    PEAK_DATA_STREAM_FLUSH_MODE_UNQUEUED_TO_INPUT_POOL,
    PEAK_DATA_STREAM_FLUSH_MODE_DISCARD_ALL,
 
    PEAK_DATA_STREAM_FLUSH_MODE_CUSTOM = 1000
};
typedef int32_t PEAK_DATA_STREAM_FLUSH_MODE;

enum PEAK_DEVICE_ACCESS_STATUS_t
{
    PEAK_DEVICE_ACCESS_STATUS_READ_WRITE = 1,
    PEAK_DEVICE_ACCESS_STATUS_READ_ONLY,
    PEAK_DEVICE_ACCESS_STATUS_NO_ACCESS,
    PEAK_DEVICE_ACCESS_STATUS_BUSY,
    PEAK_DEVICE_ACCESS_STATUS_OPEN_READ_WRITE,
    PEAK_DEVICE_ACCESS_STATUS_OPEN_READ_ONLY,
 
    PEAK_DEVICE_ACCESS_STATUS_CUSTOM = 1000
};
typedef int32_t PEAK_DEVICE_ACCESS_STATUS;

enum PEAK_DEVICE_ACCESS_TYPE_t
{
    PEAK_DEVICE_ACCESS_TYPE_READ_ONLY = 2,
    PEAK_DEVICE_ACCESS_TYPE_CONTROL,
    PEAK_DEVICE_ACCESS_TYPE_EXCLUSIVE,
 
    PEAK_DEVICE_ACCESS_TYPE_CUSTOM = 1000
};
typedef int32_t PEAK_DEVICE_ACCESS_TYPE;

enum PEAK_DEVICE_INFORMATION_ROLE_t
{
    PEAK_DEVICE_INFORMATION_ROLE_ID = 0,
    PEAK_DEVICE_INFORMATION_ROLE_VENDOR_NAME,
    PEAK_DEVICE_INFORMATION_ROLE_MODEL_NAME,
    PEAK_DEVICE_INFORMATION_ROLE_TL_TYPE,
    PEAK_DEVICE_INFORMATION_ROLE_DISPLAY_NAME,
    PEAK_DEVICE_INFORMATION_ROLE_ACCESS_STATUS,
    PEAK_DEVICE_INFORMATION_ROLE_USER_DEFINED_NAME,
    PEAK_DEVICE_INFORMATION_ROLE_SERIAL_NUMBER,
    PEAK_DEVICE_INFORMATION_ROLE_VERSION,
    PEAK_DEVICE_INFORMATION_ROLE_TIMESTAMP_TICK_FREQUENCY,
 
    PEAK_DEVICE_INFORMATION_ROLE_CUSTOM = 1000
};
typedef int32_t PEAK_DEVICE_INFORMATION_ROLE;

enum PEAK_ENDIANNESS_t
{
    PEAK_ENDIANNESS_UNKNOWN = 0,
    PEAK_ENDIANNESS_LITTLE,
    PEAK_ENDIANNESS_BIG
};
typedef int32_t PEAK_ENDIANNESS;

enum PEAK_EVENT_TYPE_t
{
    PEAK_EVENT_TYPE_ERROR = 0,
    PEAK_EVENT_TYPE_FEATURE_INVALIDATE = 2,
    PEAK_EVENT_TYPE_FEATURE_CHANGE,
    PEAK_EVENT_TYPE_REMOTE_DEVICE,
    PEAK_EVENT_TYPE_MODULE,
 
    PEAK_EVENT_TYPE_FEATURE_CUSTOM = 1000
};
typedef int32_t PEAK_EVENT_TYPE;

enum PEAK_FIRMWARE_UPDATE_PERSISTENCE_t
{
    PEAK_FIRMWARE_UPDATE_PERSISTENCE_NONE = 0,
    PEAK_FIRMWARE_UPDATE_PERSISTENCE_FULL
};
typedef int32_t PEAK_FIRMWARE_UPDATE_PERSISTENCE;

enum PEAK_FIRMWARE_UPDATE_STEP_t
{
    PEAK_FIRMWARE_UPDATE_STEP_CHECK_PRECONDITIONS = 0,
    PEAK_FIRMWARE_UPDATE_STEP_ACQUIRE_UPDATE_DATA,
    PEAK_FIRMWARE_UPDATE_STEP_WRITE_FEATURE,
    PEAK_FIRMWARE_UPDATE_STEP_EXECUTE_FEATURE,
    PEAK_FIRMWARE_UPDATE_STEP_ASSERT_FEATURE,
    PEAK_FIRMWARE_UPDATE_STEP_UPLOAD_FILE,
    PEAK_FIRMWARE_UPDATE_STEP_RESET_DEVICE
};
typedef int32_t PEAK_FIRMWARE_UPDATE_STEP;

enum PEAK_FIRMWARE_UPDATE_VERSION_STYLE_t
{
    PEAK_FIRMWARE_UPDATE_VERSION_STYLE_DOTTED = 0,
    PEAK_FIRMWARE_UPDATE_VERSION_STYLE_SEMANTIC
};
typedef int32_t PEAK_FIRMWARE_UPDATE_VERSION_STYLE;

enum PEAK_NODE_ACCESS_STATUS_t
{
    PEAK_NODE_ACCESS_STATUS_NOT_IMPLEMENTED = 0,
    PEAK_NODE_ACCESS_STATUS_NOT_AVAILABLE,
    PEAK_NODE_ACCESS_STATUS_WRITE_ONLY,
    PEAK_NODE_ACCESS_STATUS_READ_ONLY,
    PEAK_NODE_ACCESS_STATUS_READ_WRITE
};
typedef int32_t PEAK_NODE_ACCESS_STATUS;

enum PEAK_NODE_CACHING_MODE_t
{
    PEAK_NODE_CACHING_MODE_NO_CACHE = 0,
    PEAK_NODE_CACHING_MODE_WRITE_THROUGH,
    PEAK_NODE_CACHING_MODE_WRITE_AROUND
};
typedef int32_t PEAK_NODE_CACHING_MODE;

enum PEAK_NODE_CACHE_USE_POLICY_t
{
    PEAK_NODE_CACHE_USE_POLICY_USE_CACHE = 0,
    PEAK_NODE_CACHE_USE_POLICY_IGNORE_CACHE
};
typedef int32_t PEAK_NODE_CACHE_USE_POLICY;

enum PEAK_NODE_DISPLAY_NOTATION_t
{
    PEAK_NODE_DISPLAY_NOTATION_AUTOMATIC = 0,
    PEAK_NODE_DISPLAY_NOTATION_FIXED,
    PEAK_NODE_DISPLAY_NOTATION_SCIENTIFIC
};
typedef int32_t PEAK_NODE_DISPLAY_NOTATION;

enum PEAK_NODE_INCREMENT_TYPE_t
{
    PEAK_NODE_INCREMENT_TYPE_NO_INCREMENT = 0,
    PEAK_NODE_INCREMENT_TYPE_FIXED_INCREMENT,
    PEAK_NODE_INCREMENT_TYPE_LIST_INCREMENT
};
typedef int32_t PEAK_NODE_INCREMENT_TYPE;

enum PEAK_NODE_NAMESPACE_t
{
    PEAK_NODE_NAMESPACE_CUSTOM = 0,
    PEAK_NODE_NAMESPACE_STANDARD
};
typedef int32_t PEAK_NODE_NAMESPACE;

enum PEAK_NODE_REPRESENTATION_t
{
    PEAK_NODE_REPRESENTATION_LINEAR = 0,
    PEAK_NODE_REPRESENTATION_LOGARITHMIC,
    PEAK_NODE_REPRESENTATION_BOOLEAN,
    PEAK_NODE_REPRESENTATION_PURE_NUMBER,
    PEAK_NODE_REPRESENTATION_HEX_NUMBER,
    PEAK_NODE_REPRESENTATION_IP4_ADDRESS,
    PEAK_NODE_REPRESENTATION_MAC_ADDRESS
};
typedef int32_t PEAK_NODE_REPRESENTATION;

enum PEAK_NODE_TYPE_t
{
    PEAK_NODE_TYPE_INTEGER = 0,
    PEAK_NODE_TYPE_BOOLEAN,
    PEAK_NODE_TYPE_COMMAND,
    PEAK_NODE_TYPE_FLOAT,
    PEAK_NODE_TYPE_STRING,
    PEAK_NODE_TYPE_REGISTER,
    PEAK_NODE_TYPE_CATEGORY,
    PEAK_NODE_TYPE_ENUMERATION,
    PEAK_NODE_TYPE_ENUMERATION_ENTRY
};
typedef int32_t PEAK_NODE_TYPE;

enum PEAK_NODE_VISIBILITY_t
{
    PEAK_NODE_VISIBILITY_BEGINNER = 0,
    PEAK_NODE_VISIBILITY_EXPERT,
    PEAK_NODE_VISIBILITY_GURU,
    PEAK_NODE_VISIBILITY_INVISIBLE
};
typedef int32_t PEAK_NODE_VISIBILITY;

enum PEAK_PIXEL_FORMAT_NAMESPACE_t
{
    PEAK_PIXEL_FORMAT_NAMESPACE_GEV = 1,
    PEAK_PIXEL_FORMAT_NAMESPACE_IIDC,
    PEAK_PIXEL_FORMAT_NAMESPACE_PFNC_16_BIT,
    PEAK_PIXEL_FORMAT_NAMESPACE_PFNC_32_BIT,
 
    PEAK_PIXEL_FORMAT_NAMESPACE_CUSTOM = 1000
};
typedef int32_t PEAK_PIXEL_FORMAT_NAMESPACE;

enum PEAK_PORT_URL_SCHEME_t
{
    PEAK_PORT_URL_SCHEME_LOCAL = 0,
    PEAK_PORT_URL_SCHEME_HTTP,
    PEAK_PORT_URL_SCHEME_FILE,
 
    PEAK_PORT_URL_SCHEME_CUSTOM = 1000
};
typedef int32_t PEAK_PORT_URL_SCHEME;

enum PEAK_RETURN_CODE_t
{
    PEAK_RETURN_CODE_SUCCESS = 0,
    PEAK_RETURN_CODE_ERROR,
    PEAK_RETURN_CODE_NOT_INITIALIZED,
    PEAK_RETURN_CODE_ABORTED,
    PEAK_RETURN_CODE_BAD_ACCESS,
    PEAK_RETURN_CODE_BAD_ALLOC,
    PEAK_RETURN_CODE_BUFFER_TOO_SMALL,
    PEAK_RETURN_CODE_INVALID_ADDRESS,
    PEAK_RETURN_CODE_INVALID_ARGUMENT,
    PEAK_RETURN_CODE_INVALID_CAST,
    PEAK_RETURN_CODE_INVALID_HANDLE,
    PEAK_RETURN_CODE_NOT_FOUND,
    PEAK_RETURN_CODE_OUT_OF_RANGE,
    PEAK_RETURN_CODE_TIMEOUT,
    PEAK_RETURN_CODE_NOT_AVAILABLE,
    PEAK_RETURN_CODE_NOT_IMPLEMENTED,
    PEAK_RETURN_CODE_CTI_LOADING_ERROR,
    PEAK_RETURN_CODE_IO,
    PEAK_RETURN_CODE_NO_DATA
 
};
typedef int32_t PEAK_RETURN_CODE;

static const uint64_t PEAK_INFINITE_NUMBER = 0xFFFFFFFFFFFFFFFFULL;

static const uint64_t PEAK_INFINITE_TIMEOUT = 0xFFFFFFFFFFFFFFFFULL;
 
struct PEAK_PRODUCER_LIBRARY;
typedef struct PEAK_PRODUCER_LIBRARY* PEAK_PRODUCER_LIBRARY_HANDLE;
 
struct PEAK_SYSTEM_DESCRIPTOR;
typedef struct PEAK_SYSTEM_DESCRIPTOR* PEAK_SYSTEM_DESCRIPTOR_HANDLE;
 
struct PEAK_SYSTEM;
typedef struct PEAK_SYSTEM* PEAK_SYSTEM_HANDLE;
 
struct PEAK_INTERFACE_DESCRIPTOR;
typedef struct PEAK_INTERFACE_DESCRIPTOR* PEAK_INTERFACE_DESCRIPTOR_HANDLE;
 
struct PEAK_INTERFACE;
typedef struct PEAK_INTERFACE* PEAK_INTERFACE_HANDLE;
 
struct PEAK_DEVICE_DESCRIPTOR;
typedef struct PEAK_DEVICE_DESCRIPTOR* PEAK_DEVICE_DESCRIPTOR_HANDLE;
 
struct PEAK_DEVICE;
typedef struct PEAK_DEVICE* PEAK_DEVICE_HANDLE;
 
struct PEAK_REMOTE_DEVICE;
typedef struct PEAK_REMOTE_DEVICE* PEAK_REMOTE_DEVICE_HANDLE;
 
struct PEAK_DATA_STREAM_DESCRIPTOR;
typedef struct PEAK_DATA_STREAM_DESCRIPTOR* PEAK_DATA_STREAM_DESCRIPTOR_HANDLE;
 
struct PEAK_DATA_STREAM;
typedef struct PEAK_DATA_STREAM* PEAK_DATA_STREAM_HANDLE;
 
struct PEAK_BUFFER;
typedef struct PEAK_BUFFER* PEAK_BUFFER_HANDLE;
 
struct PEAK_BUFFER_CHUNK;
typedef struct PEAK_BUFFER_CHUNK* PEAK_BUFFER_CHUNK_HANDLE;
 
struct PEAK_BUFFER_PART;
typedef struct PEAK_BUFFER_PART* PEAK_BUFFER_PART_HANDLE;
 
struct PEAK_MODULE_DESCRIPTOR;
typedef struct PEAK_MODULE_DESCRIPTOR* PEAK_MODULE_DESCRIPTOR_HANDLE;
 
struct PEAK_MODULE;
typedef struct PEAK_MODULE* PEAK_MODULE_HANDLE;
 
struct PEAK_NODE_MAP;
typedef struct PEAK_NODE_MAP* PEAK_NODE_MAP_HANDLE;
 
struct PEAK_NODE;
typedef struct PEAK_NODE* PEAK_NODE_HANDLE;
 
struct PEAK_INTEGER_NODE;
typedef struct PEAK_INTEGER_NODE* PEAK_INTEGER_NODE_HANDLE;
 
struct PEAK_BOOLEAN_NODE;
typedef struct PEAK_BOOLEAN_NODE* PEAK_BOOLEAN_NODE_HANDLE;
 
struct PEAK_COMMAND_NODE;
typedef struct PEAK_COMMAND_NODE* PEAK_COMMAND_NODE_HANDLE;
 
struct PEAK_FLOAT_NODE;
typedef struct PEAK_FLOAT_NODE* PEAK_FLOAT_NODE_HANDLE;
 
struct PEAK_STRING_NODE;
typedef struct PEAK_STRING_NODE* PEAK_STRING_NODE_HANDLE;
 
struct PEAK_REGISTER_NODE;
typedef struct PEAK_REGISTER_NODE* PEAK_REGISTER_NODE_HANDLE;
 
struct PEAK_CATEGORY_NODE;
typedef struct PEAK_CATEGORY_NODE* PEAK_CATEGORY_NODE_HANDLE;
 
struct PEAK_ENUMERATION_NODE;
typedef struct PEAK_ENUMERATION_NODE* PEAK_ENUMERATION_NODE_HANDLE;
 
struct PEAK_ENUMERATION_ENTRY_NODE;
typedef struct PEAK_ENUMERATION_ENTRY_NODE* PEAK_ENUMERATION_ENTRY_NODE_HANDLE;
 
struct PEAK_PORT;
typedef struct PEAK_PORT* PEAK_PORT_HANDLE;
 
struct PEAK_PORT_URL;
typedef struct PEAK_PORT_URL* PEAK_PORT_URL_HANDLE;
 
struct PEAK_EVENT_SUPPORTING_MODULE;
typedef struct PEAK_EVENT_SUPPORTING_MODULE* PEAK_EVENT_SUPPORTING_MODULE_HANDLE;
 
struct PEAK_EVENT_CONTROLLER;
typedef struct PEAK_EVENT_CONTROLLER* PEAK_EVENT_CONTROLLER_HANDLE;
 
struct PEAK_EVENT;
typedef struct PEAK_EVENT* PEAK_EVENT_HANDLE;
 
struct PEAK_FILE_ADAPTER;
typedef struct PEAK_FILE_ADAPTER* PEAK_FILE_ADAPTER_HANDLE;
 
struct PEAK_FIRMWARE_UPDATER;
typedef struct PEAK_FIRMWARE_UPDATER* PEAK_FIRMWARE_UPDATER_HANDLE;
 
struct PEAK_FIRMWARE_UPDATE_INFORMATION;
typedef struct PEAK_FIRMWARE_UPDATE_INFORMATION* PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE;
 
struct PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER;
typedef struct PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER* PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE;
 

typedef void(PEAK_CALL_CONV* PEAK_INTERFACE_FOUND_CALLBACK)(
    PEAK_INTERFACE_DESCRIPTOR_HANDLE foundInterface, void* context);
typedef void(PEAK_CALL_CONV* PEAK_INTERFACE_LOST_CALLBACK)(
    const char* lostInterfaceId, size_t lostInterfaceIdSize, void* context);
typedef void(PEAK_CALL_CONV* PEAK_INTERFACE_LIST_CHANGED_CALLBACK)(void* context);
typedef PEAK_INTERFACE_FOUND_CALLBACK* PEAK_INTERFACE_FOUND_CALLBACK_HANDLE;
typedef PEAK_INTERFACE_LOST_CALLBACK* PEAK_INTERFACE_LOST_CALLBACK_HANDLE;
typedef PEAK_INTERFACE_LIST_CHANGED_CALLBACK* PEAK_INTERFACE_LIST_CHANGED_CALLBACK_HANDLE;
 
enum PEAK_DEVICE_RECONNECT_ERROR_t
{
    PEAK_DEVICE_RECONNECT_OPERATION_NO_ERROR = 0x0,
    PEAK_DEVICE_RECONNECT_OPERATION_REMOTE_DEVICE_ACQUISITION_RESTART_ERROR = 0x1000000,
    PEAK_DEVICE_RECONNECT_OPERATION_REMOTE_DEVICE_ACQUISITION_RESTART_PAYLOAD_SIZE_LARGER_THAN_BUFFERS = 0x1000001,
    PEAK_DEVICE_RECONNECT_OPERATION_REMOTE_DEVICE_CONFIGURATION_RESTORE_ERROR = 0x2000000,
};
typedef uint32_t PEAK_DEVICE_RECONNECT_ERROR_FLAGS;

typedef struct
{
    PEAK_BOOL8 IsRemoteDeviceAcquisitionRunning;
    PEAK_BOOL8 IsRemoteDeviceConfigurationRestored;
    PEAK_BOOL8 Reserved[6];

    PEAK_DEVICE_RECONNECT_ERROR_FLAGS ErrorFlags;

    uint8_t Reserved2[20];
} PEAK_DEVICE_RECONNECT_INFORMATION;

typedef void(PEAK_CALL_CONV* PEAK_DEVICE_FOUND_CALLBACK)(
    PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void* context);
typedef void(PEAK_CALL_CONV* PEAK_DEVICE_RECONNECTED_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE reconnectedDevice,
    PEAK_DEVICE_RECONNECT_INFORMATION reconnectInformation, void* context);
typedef void(PEAK_CALL_CONV* PEAK_DEVICE_LOST_CALLBACK)(
    const char* lostDeviceId, size_t lostDeviceIdSize, void* context);
typedef void(PEAK_CALL_CONV* PEAK_DEVICE_DISCONNETED_CALLBACK)(
    PEAK_DEVICE_DESCRIPTOR_HANDLE disconnectedDevice, void* context);
typedef void(PEAK_CALL_CONV* PEAK_DEVICE_LIST_CHANGED_CALLBACK)(void* context);
typedef PEAK_DEVICE_FOUND_CALLBACK* PEAK_DEVICE_FOUND_CALLBACK_HANDLE;
typedef PEAK_DEVICE_RECONNECTED_CALLBACK* PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE;
typedef PEAK_DEVICE_DISCONNETED_CALLBACK* PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE;
typedef PEAK_DEVICE_LOST_CALLBACK* PEAK_DEVICE_LOST_CALLBACK_HANDLE;
typedef PEAK_DEVICE_LIST_CHANGED_CALLBACK* PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE;

typedef void(PEAK_CALL_CONV* PEAK_BUFFER_REVOCATION_CALLBACK)(void* buffer, void* userPtr, void* context);

typedef void(PEAK_CALL_CONV* PEAK_NODE_CHANGED_CALLBACK)(PEAK_NODE_HANDLE changedNode, void* context);
typedef PEAK_NODE_CHANGED_CALLBACK* PEAK_NODE_CHANGED_CALLBACK_HANDLE;

typedef void(PEAK_CALL_CONV* PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK)(
    const PEAK_DEVICE_INFORMATION_ROLE* changedRoles, size_t changedRolesSize, void* context);
typedef PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK*
    PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE;

typedef void(PEAK_CALL_CONV* PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK)(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, uint32_t estimatedDuration_ms,
    void* context);
typedef PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK* PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE;
typedef void(PEAK_CALL_CONV* PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep,
    uint32_t estimatedDuration_ms, const char* description, size_t descriptionSize, void* context);
typedef PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK* PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE;
typedef void(PEAK_CALL_CONV* PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK)(
    PEAK_FIRMWARE_UPDATE_STEP updateStep, double progressPercentage, void* context);
typedef PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK*
    PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE;
typedef void(PEAK_CALL_CONV* PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK)(
    PEAK_FIRMWARE_UPDATE_STEP updateStep, void* context);
typedef PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK* PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE;
typedef void(PEAK_CALL_CONV* PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK)(void* context);
typedef PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK* PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE;
typedef void(PEAK_CALL_CONV* PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK)(
    const char* errorDescription, size_t errorDescriptionSize, void* context);
typedef PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK* PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE;
 
 
#define PEAK_C_API PEAK_PUBLIC PEAK_RETURN_CODE PEAK_CALL_CONV
 
#ifndef PEAK_DYNAMIC_LOADING
PEAK_C_API PEAK_Library_Initialize();
PEAK_C_API PEAK_Library_Close();
PEAK_C_API PEAK_Library_IsInitialized(PEAK_BOOL8* isInitialized);
PEAK_C_API PEAK_Library_GetVersionMajor(uint32_t* libraryVersionMajor);
PEAK_C_API PEAK_Library_GetVersionMinor(uint32_t* libraryVersionMinor);

PEAK_COMMON_DEPRECATED_MSG("Deprecated due to SemVer 2.0 migration. Use PEAK_Library_GetVersionPatch() instead.")
PEAK_C_API PEAK_Library_GetVersionSubminor(uint32_t* libraryVersionSubminor);

PEAK_C_API PEAK_Library_GetVersionPatch(uint32_t* libraryVersionPatch);
PEAK_C_API PEAK_Library_GetLastError(
    PEAK_RETURN_CODE* lastErrorCode, char* lastErrorDescription, size_t* lastErrorDescriptionSize);

PEAK_C_API PEAK_EnvironmentInspector_UpdateCTIPaths();
PEAK_C_API PEAK_EnvironmentInspector_GetNumCTIPaths(size_t* numCtiPaths);
PEAK_C_API PEAK_EnvironmentInspector_GetCTIPath(size_t index, char* ctiPath, size_t* ctiPathSize);

PEAK_C_API PEAK_ProducerLibrary_Construct(
    const char* ctiPath, size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE* producerLibraryHandle);
PEAK_C_API PEAK_ProducerLibrary_GetKey(
    PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, char* key, size_t* keySize);
PEAK_C_API PEAK_ProducerLibrary_GetSystem(
    PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE* systemDescriptorHandle);
PEAK_C_API PEAK_ProducerLibrary_Destruct(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle);

PEAK_C_API PEAK_SystemDescriptor_ToModuleDescriptor(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
PEAK_C_API PEAK_SystemDescriptor_GetKey(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char* key, size_t* keySize);
PEAK_C_API PEAK_SystemDescriptor_GetInfo(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
    int32_t infoCommand, int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_SystemDescriptor_GetDisplayName(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char* displayName, size_t* displayNameSize);
PEAK_C_API PEAK_SystemDescriptor_GetVendorName(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char* vendorName, size_t* vendorNameSize);
PEAK_C_API PEAK_SystemDescriptor_GetModelName(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char* modelName, size_t* modelNameSize);
PEAK_C_API PEAK_SystemDescriptor_GetVersion(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char* version, size_t* versionSize);
PEAK_C_API PEAK_SystemDescriptor_GetTLType(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char* tlType, size_t* tlTypeSize);
PEAK_C_API PEAK_SystemDescriptor_GetCTIFileName(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char* ctiFileName, size_t* ctiFileNameSize);
PEAK_C_API PEAK_SystemDescriptor_GetCTIFullPath(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char* ctiFullPath, size_t* ctiFullPathSize);
PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMajor(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t* gentlVersionMajor);
PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMinor(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t* gentlVersionMinor);
PEAK_C_API PEAK_SystemDescriptor_GetCharacterEncoding(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING* characterEncoding);
PEAK_C_API PEAK_SystemDescriptor_GetParentLibrary(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE* producerLibraryHandle);
PEAK_C_API PEAK_SystemDescriptor_OpenSystem(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE* systemHandle);

PEAK_C_API PEAK_System_ToModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_MODULE_HANDLE* moduleHandle);
PEAK_C_API PEAK_System_ToEventSupportingModule(
    PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
PEAK_C_API PEAK_System_GetKey(PEAK_SYSTEM_HANDLE systemHandle, char* key, size_t* keySize);
PEAK_C_API PEAK_System_GetInfo(
    PEAK_SYSTEM_HANDLE systemHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_System_GetID(PEAK_SYSTEM_HANDLE systemHandle, char* id, size_t* idSize);
PEAK_C_API PEAK_System_GetDisplayName(
    PEAK_SYSTEM_HANDLE systemHandle, char* displayName, size_t* displayNameSize);
PEAK_C_API PEAK_System_GetVendorName(
    PEAK_SYSTEM_HANDLE systemHandle, char* vendorName, size_t* vendorNameSize);
PEAK_C_API PEAK_System_GetModelName(PEAK_SYSTEM_HANDLE systemHandle, char* modelName, size_t* modelNameSize);
PEAK_C_API PEAK_System_GetVersion(PEAK_SYSTEM_HANDLE systemHandle, char* version, size_t* versionSize);
PEAK_C_API PEAK_System_GetTLType(PEAK_SYSTEM_HANDLE systemHandle, char* tlType, size_t* tlTypeSize);
PEAK_C_API PEAK_System_GetCTIFileName(
    PEAK_SYSTEM_HANDLE systemHandle, char* ctiFileName, size_t* ctiFileNameSize);
PEAK_C_API PEAK_System_GetCTIFullPath(
    PEAK_SYSTEM_HANDLE systemHandle, char* ctiFullPath, size_t* ctiFullPathSize);
PEAK_C_API PEAK_System_GetGenTLVersionMajor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t* gentlVersionMajor);
PEAK_C_API PEAK_System_GetGenTLVersionMinor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t* gentlVersionMinor);
PEAK_C_API PEAK_System_GetCharacterEncoding(
    PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING* characterEncoding);
PEAK_C_API PEAK_System_GetParentLibrary(
    PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE* producerLibraryHandle);
PEAK_C_API PEAK_System_UpdateInterfaces(PEAK_SYSTEM_HANDLE systemHandle, uint64_t timeout_ms);
PEAK_C_API PEAK_System_GetNumInterfaces(PEAK_SYSTEM_HANDLE systemHandle, size_t* numInterfaces);
PEAK_C_API PEAK_System_GetInterface(
    PEAK_SYSTEM_HANDLE systemHandle, size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE* interfaceDescriptorHandle);
PEAK_C_API PEAK_System_RegisterInterfaceFoundCallback(PEAK_SYSTEM_HANDLE systemHandle,
    PEAK_INTERFACE_FOUND_CALLBACK callback, void* callbackContext,
    PEAK_INTERFACE_FOUND_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_System_UnregisterInterfaceFoundCallback(
    PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle);
PEAK_C_API PEAK_System_RegisterInterfaceLostCallback(PEAK_SYSTEM_HANDLE systemHandle,
    PEAK_INTERFACE_LOST_CALLBACK callback, void* callbackContext,
    PEAK_INTERFACE_LOST_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_System_UnregisterInterfaceLostCallback(
    PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle);
PEAK_C_API PEAK_System_Destruct(PEAK_SYSTEM_HANDLE systemHandle);

PEAK_C_API PEAK_InterfaceDescriptor_ToModuleDescriptor(
    PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle,
    PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
PEAK_C_API PEAK_InterfaceDescriptor_GetKey(
    PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char* key, size_t* keySize);
PEAK_C_API PEAK_InterfaceDescriptor_GetInfo(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle,
    int32_t infoCommand, int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_InterfaceDescriptor_GetDisplayName(
    PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char* displayName, size_t* displayNameSize);
PEAK_C_API PEAK_InterfaceDescriptor_GetTLType(
    PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char* tlType, size_t* tlTypeSize);
PEAK_C_API PEAK_InterfaceDescriptor_GetParentSystem(
    PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE* systemHandle);
PEAK_C_API PEAK_InterfaceDescriptor_OpenInterface(
    PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE* interfaceHandle);

PEAK_C_API PEAK_Interface_ToModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_MODULE_HANDLE* moduleHandle);
PEAK_C_API PEAK_Interface_ToEventSupportingModule(
    PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
PEAK_C_API PEAK_Interface_GetKey(PEAK_INTERFACE_HANDLE interfaceHandle, char* key, size_t* keySize);
PEAK_C_API PEAK_Interface_GetInfo(PEAK_INTERFACE_HANDLE interfaceHandle, int32_t infoCommand,
    int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_Interface_GetID(PEAK_INTERFACE_HANDLE interfaceHandle, char* id, size_t* idSize);
PEAK_C_API PEAK_Interface_GetDisplayName(
    PEAK_INTERFACE_HANDLE interfaceHandle, char* displayName, size_t* displayNameSize);
PEAK_C_API PEAK_Interface_GetTLType(PEAK_INTERFACE_HANDLE interfaceHandle, char* tlType, size_t* tlTypeSize);
PEAK_C_API PEAK_Interface_GetParentSystem(
    PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE* systemHandle);
PEAK_C_API PEAK_Interface_UpdateDevices(PEAK_INTERFACE_HANDLE interfaceHandle, uint64_t timeout_ms);
PEAK_C_API PEAK_Interface_GetNumDevices(PEAK_INTERFACE_HANDLE interfaceHandle, size_t* numDevices);
PEAK_C_API PEAK_Interface_GetDevice(
    PEAK_INTERFACE_HANDLE interfaceHandle, size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE* deviceDescriptorHandle);
PEAK_C_API PEAK_Interface_RegisterDeviceFoundCallback(PEAK_INTERFACE_HANDLE interfaceHandle,
    PEAK_DEVICE_FOUND_CALLBACK callback, void* callbackContext,
    PEAK_DEVICE_FOUND_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_Interface_UnregisterDeviceFoundCallback(
    PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle);

PEAK_C_API PEAK_Interface_RegisterDeviceReconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle,
    PEAK_DEVICE_RECONNECTED_CALLBACK callback, void* callbackContext,
    PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_Interface_UnregisterDeviceReconnectedCallback(
    PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle);
PEAK_C_API PEAK_Interface_RegisterDeviceDisconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle,
    PEAK_DEVICE_DISCONNETED_CALLBACK callback, void* callbackContext,
    PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_Interface_UnregisterDeviceDisconnectedCallback(
    PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle);

PEAK_C_API PEAK_Interface_RegisterDeviceLostCallback(PEAK_INTERFACE_HANDLE interfaceHandle,
    PEAK_DEVICE_LOST_CALLBACK callback, void* callbackContext, PEAK_DEVICE_LOST_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_Interface_UnregisterDeviceLostCallback(
    PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle);

PEAK_C_API PEAK_Interface_RegisterDeviceListChangedCallback(PEAK_INTERFACE_HANDLE interfaceHandle,
    PEAK_DEVICE_LIST_CHANGED_CALLBACK callback, void* callbackContext,
    PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_Interface_UnregisterDeviceListChangedCallback(
    PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle);

PEAK_C_API PEAK_Interface_Destruct(PEAK_INTERFACE_HANDLE interfaceHandle);

PEAK_C_API PEAK_DeviceDescriptor_ToModuleDescriptor(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
PEAK_C_API PEAK_DeviceDescriptor_GetKey(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char* key, size_t* keySize);
PEAK_C_API PEAK_DeviceDescriptor_GetInfo(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
    int32_t infoCommand, int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_DeviceDescriptor_GetDisplayName(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char* displayName, size_t* displayNameSize);
PEAK_C_API PEAK_DeviceDescriptor_GetVendorName(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char* vendorName, size_t* vendorNameSize);
PEAK_C_API PEAK_DeviceDescriptor_GetModelName(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char* modelName, size_t* modelNameSize);
PEAK_C_API PEAK_DeviceDescriptor_GetVersion(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char* version, size_t* versionSize);
PEAK_C_API PEAK_DeviceDescriptor_GetTLType(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char* tlType, size_t* tlTypeSize);
PEAK_C_API PEAK_DeviceDescriptor_GetUserDefinedName(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char* userDefinedName, size_t* userDefinedNameSize);
PEAK_C_API PEAK_DeviceDescriptor_GetSerialNumber(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char* serialNumber, size_t* serialNumberSize);
PEAK_C_API PEAK_DeviceDescriptor_GetAccessStatus(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS* accessStatus);
PEAK_C_API PEAK_DeviceDescriptor_GetTimestampTickFrequency(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t* timestampTickFrequency);
PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenableExclusive(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8* isOpenable);
PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenable(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
    PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_BOOL8* isOpenable);
PEAK_C_API PEAK_DeviceDescriptor_OpenDevice(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
    PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_DEVICE_HANDLE* deviceHandle);
PEAK_C_API PEAK_DeviceDescriptor_GetParentInterface(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE* interfaceHandle);
PEAK_C_API PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t* monitoringUpdateInterval_ms);
PEAK_C_API PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms);
PEAK_C_API PEAK_DeviceDescriptor_IsInformationRoleMonitored(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole,
    PEAK_BOOL8* isInformationRoleMonitored);
PEAK_C_API PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole);
PEAK_C_API PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole);
PEAK_C_API PEAK_DeviceDescriptor_RegisterInformationChangedCallback(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
    PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK callback, void* callbackContext,
    PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_DeviceDescriptor_UnregisterInformationChangedCallback(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
    PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE callbackHandle);

PEAK_C_API PEAK_Device_ToModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_MODULE_HANDLE* moduleHandle);
PEAK_C_API PEAK_Device_ToEventSupportingModule(
    PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
PEAK_C_API PEAK_Device_GetKey(PEAK_DEVICE_HANDLE deviceHandle, char* key, size_t* keySize);
PEAK_C_API PEAK_Device_GetInfo(
    PEAK_DEVICE_HANDLE deviceHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_Device_GetID(PEAK_DEVICE_HANDLE deviceHandle, char* id, size_t* idSize);
PEAK_C_API PEAK_Device_GetDisplayName(
    PEAK_DEVICE_HANDLE deviceHandle, char* displayName, size_t* displayNameSize);
PEAK_C_API PEAK_Device_GetVendorName(
    PEAK_DEVICE_HANDLE deviceHandle, char* vendorName, size_t* vendorNameSize);
PEAK_C_API PEAK_Device_GetModelName(PEAK_DEVICE_HANDLE deviceHandle, char* modelName, size_t* modelNameSize);
PEAK_C_API PEAK_Device_GetVersion(PEAK_DEVICE_HANDLE deviceHandle, char* version, size_t* versionSize);
PEAK_C_API PEAK_Device_GetTLType(PEAK_DEVICE_HANDLE deviceHandle, char* tlType, size_t* tlTypeSize);
PEAK_C_API PEAK_Device_GetUserDefinedName(
    PEAK_DEVICE_HANDLE deviceHandle, char* userDefinedName, size_t* userDefinedNameSize);
PEAK_C_API PEAK_Device_GetSerialNumber(
    PEAK_DEVICE_HANDLE deviceHandle, char* serialNumber, size_t* serialNumberSize);
PEAK_C_API PEAK_Device_GetAccessStatus(
    PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS* accessStatus);
PEAK_C_API PEAK_Device_GetTimestampTickFrequency(
    PEAK_DEVICE_HANDLE deviceHandle, uint64_t* timestampTickFrequency);
PEAK_C_API PEAK_Device_GetParentInterface(
    PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE* interfaceHandle);
PEAK_C_API PEAK_Device_GetRemoteDevice(
    PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE* remoteDeviceHandle);
PEAK_C_API PEAK_Device_GetNumDataStreams(PEAK_DEVICE_HANDLE deviceHandle, size_t* numDataStreams);
PEAK_C_API PEAK_Device_GetDataStream(PEAK_DEVICE_HANDLE deviceHandle, size_t index,
    PEAK_DATA_STREAM_DESCRIPTOR_HANDLE* dataStreamDescriptorHandle);
PEAK_C_API PEAK_Device_Destruct(PEAK_DEVICE_HANDLE deviceHandle);

PEAK_C_API PEAK_RemoteDevice_ToModule(
    PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE* moduleHandle);
PEAK_C_API PEAK_RemoteDevice_GetLocalDevice(
    PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE* deviceHandle);

PEAK_C_API PEAK_DataStreamDescriptor_ToModuleDescriptor(
    PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle,
    PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
PEAK_C_API PEAK_DataStreamDescriptor_GetKey(
    PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, char* key, size_t* keySize);
PEAK_C_API PEAK_DataStreamDescriptor_GetParentDevice(
    PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE* deviceHandle);
PEAK_C_API PEAK_DataStreamDescriptor_OpenDataStream(
    PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE* dataStreamHandle);

PEAK_C_API PEAK_DataStream_ToModule(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE* moduleHandle);
PEAK_C_API PEAK_DataStream_ToEventSupportingModule(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
PEAK_C_API PEAK_DataStream_GetKey(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char* key, size_t* keySize);
PEAK_C_API PEAK_DataStream_GetInfo(PEAK_DATA_STREAM_HANDLE dataStreamHandle, int32_t infoCommand,
    int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_DataStream_GetID(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char* id, size_t* idSize);
PEAK_C_API PEAK_DataStream_GetTLType(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, char* tlType, size_t* tlTypeSize);
PEAK_C_API PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t* numBuffersAnnouncedMinRequired);
PEAK_C_API PEAK_DataStream_GetNumBuffersAnnounced(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t* numBuffersAnnounced);
PEAK_C_API PEAK_DataStream_GetNumBuffersQueued(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t* numBuffersQueued);
PEAK_C_API PEAK_DataStream_GetNumBuffersAwaitDelivery(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t* numBuffersAwaitDelivery);
PEAK_C_API PEAK_DataStream_GetNumBuffersDelivered(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t* numBuffersDelivered);
PEAK_C_API PEAK_DataStream_GetNumBuffersStarted(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t* numBuffersStarted);
PEAK_C_API PEAK_DataStream_GetNumUnderruns(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t* numUnderruns);
PEAK_C_API PEAK_DataStream_GetNumChunksPerBufferMax(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t* numChunksPerBufferMax);
PEAK_C_API PEAK_DataStream_GetBufferAlignment(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t* bufferAlignment);
PEAK_C_API PEAK_DataStream_GetPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t* payloadSize);
PEAK_C_API PEAK_DataStream_GetDefinesPayloadSize(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8* definesPayloadSize);
PEAK_C_API PEAK_DataStream_GetIsGrabbing(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8* isGrabbing);
PEAK_C_API PEAK_DataStream_GetParentDevice(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE* deviceHandle);
PEAK_C_API PEAK_DataStream_AnnounceBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, void* buffer,
    size_t bufferSize, void* userPtr, PEAK_BUFFER_REVOCATION_CALLBACK revocationCallback, void* callbackContext,
    PEAK_BUFFER_HANDLE* bufferHandle);
PEAK_C_API PEAK_DataStream_AllocAndAnnounceBuffer(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t bufferSize, void* userPtr, PEAK_BUFFER_HANDLE* bufferHandle);
PEAK_C_API PEAK_DataStream_QueueBuffer(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle);
PEAK_C_API PEAK_DataStream_RevokeBuffer(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle);
PEAK_C_API PEAK_DataStream_WaitForFinishedBuffer(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t timeout_ms, PEAK_BUFFER_HANDLE* bufferHandle);
PEAK_C_API PEAK_DataStream_KillWait(PEAK_DATA_STREAM_HANDLE dataStreamHandle);
PEAK_C_API PEAK_DataStream_FlushPendingKillWaits(PEAK_DATA_STREAM_HANDLE dataStreamHandle);
PEAK_C_API PEAK_DataStream_Flush(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode);
PEAK_C_API PEAK_DataStream_StartAcquisitionInfinite(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode);
PEAK_C_API PEAK_DataStream_StartAcquisition(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode, uint64_t numToAcquire);
PEAK_C_API PEAK_DataStream_StopAcquisition(
    PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode);
PEAK_C_API PEAK_DataStream_Destruct(PEAK_DATA_STREAM_HANDLE dataStreamHandle);

PEAK_C_API PEAK_Buffer_ToModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE* moduleHandle);
PEAK_C_API PEAK_Buffer_ToEventSupportingModule(
    PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
PEAK_C_API PEAK_Buffer_GetInfo(
    PEAK_BUFFER_HANDLE bufferHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_Buffer_GetTLType(PEAK_BUFFER_HANDLE bufferHandle, char* tlType, size_t* tlTypeSize);
PEAK_C_API PEAK_Buffer_GetBasePtr(PEAK_BUFFER_HANDLE bufferHandle, void** basePtr);
PEAK_C_API PEAK_Buffer_GetSize(PEAK_BUFFER_HANDLE bufferHandle, size_t* size);
PEAK_C_API PEAK_Buffer_GetUserPtr(PEAK_BUFFER_HANDLE bufferHandle, void** userPtr);
PEAK_C_API PEAK_Buffer_GetPayloadType(
    PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE* payloadType);
PEAK_C_API PEAK_Buffer_GetPixelFormat(PEAK_BUFFER_HANDLE bufferHandle, uint64_t* pixelFormat);
PEAK_C_API PEAK_Buffer_GetPixelFormatNamespace(
    PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE* pixelFormatNamespace);
PEAK_C_API PEAK_Buffer_GetPixelEndianness(
    PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS* pixelEndianness);
PEAK_C_API PEAK_Buffer_GetExpectedDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t* expectedDataSize);
PEAK_C_API PEAK_Buffer_GetDeliveredDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t* deliveredDataSize);
PEAK_C_API PEAK_Buffer_GetFrameID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t* frameId);
PEAK_C_API PEAK_Buffer_GetImageOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t* imageOffset);
PEAK_C_API PEAK_Buffer_GetDeliveredImageHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t* deliveredImageHeight);
PEAK_C_API PEAK_Buffer_GetDeliveredChunkPayloadSize(
    PEAK_BUFFER_HANDLE bufferHandle, size_t* deliveredChunkPayloadSize);
PEAK_C_API PEAK_Buffer_GetChunkLayoutID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t* chunkLayoutId);
PEAK_C_API PEAK_Buffer_GetFileName(PEAK_BUFFER_HANDLE bufferHandle, char* fileName, size_t* fileNameSize);
PEAK_C_API PEAK_Buffer_GetWidth(PEAK_BUFFER_HANDLE bufferHandle, size_t* width);
PEAK_C_API PEAK_Buffer_GetHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t* height);
PEAK_C_API PEAK_Buffer_GetXOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t* xOffset);
PEAK_C_API PEAK_Buffer_GetYOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t* yOffset);
PEAK_C_API PEAK_Buffer_GetXPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t* xPadding);
PEAK_C_API PEAK_Buffer_GetYPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t* yPadding);
PEAK_C_API PEAK_Buffer_GetTimestamp_ticks(PEAK_BUFFER_HANDLE bufferHandle, uint64_t* timestamp_ticks);
PEAK_C_API PEAK_Buffer_GetTimestamp_ns(PEAK_BUFFER_HANDLE bufferHandle, uint64_t* timestamp_ns);
PEAK_C_API PEAK_Buffer_GetIsQueued(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8* isQueued);
PEAK_C_API PEAK_Buffer_GetIsAcquiring(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8* isAcquiring);
PEAK_C_API PEAK_Buffer_GetIsIncomplete(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8* isIncomplete);
PEAK_C_API PEAK_Buffer_GetHasNewData(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8* hasNewData);
PEAK_C_API PEAK_Buffer_GetHasImage(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8* hasImage);
PEAK_C_API PEAK_Buffer_GetHasChunks(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8* hasChunks);
PEAK_C_API PEAK_Buffer_GetHasParts(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8* hasParts);
PEAK_C_API PEAK_Buffer_GetSystemTimestamp_ns(PEAK_BUFFER_HANDLE bufferHandle, uint64_t* systemTimestamp_ns);
PEAK_C_API PEAK_Buffer_UpdateChunks(PEAK_BUFFER_HANDLE bufferHandle);
PEAK_C_API PEAK_Buffer_GetNumChunks(PEAK_BUFFER_HANDLE bufferHandle, size_t* numChunks);
PEAK_C_API PEAK_Buffer_GetChunk(
    PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_CHUNK_HANDLE* bufferChunkHandle);
PEAK_C_API PEAK_Buffer_UpdateParts(PEAK_BUFFER_HANDLE bufferHandle);
PEAK_C_API PEAK_Buffer_GetNumParts(PEAK_BUFFER_HANDLE bufferHandle, size_t* numParts);
PEAK_C_API PEAK_Buffer_GetPart(
    PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_PART_HANDLE* bufferPartHandle);

PEAK_C_API PEAK_BufferChunk_GetID(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, uint64_t* id);
PEAK_C_API PEAK_BufferChunk_GetBasePtr(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void** basePtr);
PEAK_C_API PEAK_BufferChunk_GetSize(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, size_t* size);
PEAK_C_API PEAK_BufferChunk_GetParentBuffer(
    PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE* bufferHandle);

PEAK_C_API PEAK_BufferChunk_Destruct(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle);

PEAK_C_API PEAK_BufferPart_GetInfo(PEAK_BUFFER_PART_HANDLE bufferPartHandle, int32_t infoCommand,
    int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_BufferPart_GetSourceID(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t* sourceId);
PEAK_C_API PEAK_BufferPart_GetBasePtr(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void** basePtr);
PEAK_C_API PEAK_BufferPart_GetSize(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t* size);
PEAK_C_API PEAK_BufferPart_GetType(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE* type);
PEAK_C_API PEAK_BufferPart_GetFormat(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t* format);
PEAK_C_API PEAK_BufferPart_GetFormatNamespace(
    PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t* formatNamespace);
PEAK_C_API PEAK_BufferPart_GetWidth(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t* width);
PEAK_C_API PEAK_BufferPart_GetHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t* height);
PEAK_C_API PEAK_BufferPart_GetXOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t* xOffset);
PEAK_C_API PEAK_BufferPart_GetYOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t* yOffset);
PEAK_C_API PEAK_BufferPart_GetXPadding(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t* xPadding);
PEAK_C_API PEAK_BufferPart_GetDeliveredImageHeight(
    PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t* deliveredImageHeight);
PEAK_C_API PEAK_BufferPart_GetParentBuffer(
    PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE* bufferHandle);

PEAK_C_API PEAK_BufferPart_Destruct(PEAK_BUFFER_PART_HANDLE bufferPartHandle);

PEAK_C_API PEAK_ModuleDescriptor_GetID(
    PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char* id, size_t* idSize);

PEAK_C_API PEAK_Module_GetNumNodeMaps(PEAK_MODULE_HANDLE moduleHandle, size_t* numNodeMaps);
PEAK_C_API PEAK_Module_GetNodeMap(
    PEAK_MODULE_HANDLE moduleHandle, size_t index, PEAK_NODE_MAP_HANDLE* nodeMapHandle);
PEAK_C_API PEAK_Module_GetPort(PEAK_MODULE_HANDLE moduleHandle, PEAK_PORT_HANDLE* portHandle);

PEAK_C_API PEAK_NodeMap_GetHasNode(
    PEAK_NODE_MAP_HANDLE nodeMapHandle, const char* nodeName, size_t nodeNameSize, PEAK_BOOL8* hasNode);
PEAK_C_API PEAK_NodeMap_FindNode(
    PEAK_NODE_MAP_HANDLE nodeMapHandle, const char* nodeName, size_t nodeNameSize, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_NodeMap_TryFindNode(
    PEAK_NODE_MAP_HANDLE nodeMapHandle, const char* nodeName, size_t nodeNameSize, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_NodeMap_InvalidateNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle);
PEAK_C_API PEAK_NodeMap_PollNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms);
PEAK_C_API PEAK_NodeMap_GetNumNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t* numNodes);
PEAK_C_API PEAK_NodeMap_GetNode(
    PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_NodeMap_GetHasBufferSupportedChunks(
    PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8* hasSupportedChunks);
PEAK_C_API PEAK_NodeMap_UpdateChunkNodes(
    PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle);
PEAK_C_API PEAK_NodeMap_GetHasEventSupportedData(
    PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8* hasSupportedData);
PEAK_C_API PEAK_NodeMap_UpdateEventNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle);
PEAK_C_API PEAK_NodeMap_StoreToFile(
    PEAK_NODE_MAP_HANDLE nodeMapHandle, const char* filePath, size_t filePathSize);
PEAK_C_API PEAK_NodeMap_LoadFromFile(
    PEAK_NODE_MAP_HANDLE nodeMapHandle, const char* filePath, size_t filePathSize);
PEAK_C_API PEAK_NodeMap_Lock(PEAK_NODE_MAP_HANDLE nodeMapHandle);

PEAK_C_API PEAK_NodeMap_TryLock(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BOOL8* locked);

PEAK_C_API PEAK_NodeMap_Unlock(PEAK_NODE_MAP_HANDLE nodeMapHandle);
PEAK_C_API PEAK_Node_ToIntegerNode(
    PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE* integerNodeHandle);
PEAK_C_API PEAK_Node_ToBooleanNode(
    PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE* booleanNodeHandle);
PEAK_C_API PEAK_Node_ToCommandNode(
    PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE* commandNodeHandle);
PEAK_C_API PEAK_Node_ToFloatNode(PEAK_NODE_HANDLE nodeHandle, PEAK_FLOAT_NODE_HANDLE* floatNodeHandle);
PEAK_C_API PEAK_Node_ToStringNode(PEAK_NODE_HANDLE nodeHandle, PEAK_STRING_NODE_HANDLE* stringNodeHandle);
PEAK_C_API PEAK_Node_ToRegisterNode(
    PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE* registerNodeHandle);
PEAK_C_API PEAK_Node_ToCategoryNode(
    PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE* categoryNodeHandle);
PEAK_C_API PEAK_Node_ToEnumerationNode(
    PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE* enumerationNodeHandle);
PEAK_C_API PEAK_Node_ToEnumerationEntryNode(
    PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
PEAK_C_API PEAK_Node_GetName(PEAK_NODE_HANDLE nodeHandle, char* name, size_t* nameSize);
PEAK_C_API PEAK_Node_GetDisplayName(PEAK_NODE_HANDLE nodeHandle, char* displayName, size_t* displayNameSize);
PEAK_C_API PEAK_Node_GetNamespace(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE* _namespace);
PEAK_C_API PEAK_Node_GetVisibility(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY* visibility);
PEAK_C_API PEAK_Node_GetAccessStatus(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_ACCESS_STATUS* accessStatus);
PEAK_C_API PEAK_Node_GetIsCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8* isCacheable);
PEAK_C_API PEAK_Node_GetIsAccessStatusCacheable(
    PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8* isAccessStatusCacheable);
PEAK_C_API PEAK_Node_GetIsStreamable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8* isStreamable);
PEAK_C_API PEAK_Node_GetIsDeprecated(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8* isDeprecated);
PEAK_C_API PEAK_Node_GetIsFeature(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8* isFeature);
PEAK_C_API PEAK_Node_GetCachingMode(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE* cachingMode);
PEAK_C_API PEAK_Node_GetPollingTime(PEAK_NODE_HANDLE nodeHandle, int64_t* pollingTime_ms);
PEAK_C_API PEAK_Node_GetToolTip(PEAK_NODE_HANDLE nodeHandle, char* toolTip, size_t* toolTipSize);
PEAK_C_API PEAK_Node_GetDescription(PEAK_NODE_HANDLE nodeHandle, char* description, size_t* descriptionSize);
PEAK_C_API PEAK_Node_GetType(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_TYPE* type);
PEAK_C_API PEAK_Node_GetParentNodeMap(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_MAP_HANDLE* nodeMapHandle);
PEAK_C_API PEAK_Node_FindInvalidatedNode(
    PEAK_NODE_HANDLE nodeHandle, const char* name, size_t nameSize, PEAK_NODE_HANDLE* invalidatedNodeHandle);
PEAK_C_API PEAK_Node_GetNumInvalidatedNodes(PEAK_NODE_HANDLE nodeHandle, size_t* numInvalidatedNodes);
PEAK_C_API PEAK_Node_GetInvalidatedNode(
    PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE* invalidatedNodeHandle);
PEAK_C_API PEAK_Node_FindInvalidatingNode(
    PEAK_NODE_HANDLE nodeHandle, const char* name, size_t nameSize, PEAK_NODE_HANDLE* invalidatingNodeHandle);
PEAK_C_API PEAK_Node_GetNumInvalidatingNodes(PEAK_NODE_HANDLE nodeHandle, size_t* numInvalidatingNodes);
PEAK_C_API PEAK_Node_GetInvalidatingNode(
    PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE* invalidatingNodeHandle);
PEAK_C_API PEAK_Node_FindSelectedNode(
    PEAK_NODE_HANDLE nodeHandle, const char* name, size_t nameSize, PEAK_NODE_HANDLE* selectedNodeHandle);
PEAK_C_API PEAK_Node_GetNumSelectedNodes(PEAK_NODE_HANDLE nodeHandle, size_t* numSelectedNodes);
PEAK_C_API PEAK_Node_GetSelectedNode(
    PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE* selectedNodeHandle);
PEAK_C_API PEAK_Node_FindSelectingNode(
    PEAK_NODE_HANDLE nodeHandle, const char* name, size_t nameSize, PEAK_NODE_HANDLE* selectingNodeHandle);
PEAK_C_API PEAK_Node_GetNumSelectingNodes(PEAK_NODE_HANDLE nodeHandle, size_t* numSelectingNodes);
PEAK_C_API PEAK_Node_GetSelectingNode(
    PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE* selectingNodeHandle);
PEAK_C_API PEAK_Node_RegisterChangedCallback(PEAK_NODE_HANDLE nodeHandle,
    PEAK_NODE_CHANGED_CALLBACK callback, void* callbackContext,
    PEAK_NODE_CHANGED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_Node_UnregisterChangedCallback(
    PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle);

PEAK_C_API PEAK_IntegerNode_ToNode(
    PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_IntegerNode_GetMinimum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t* minimum);
PEAK_C_API PEAK_IntegerNode_GetMaximum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t* maximum);
PEAK_C_API PEAK_IntegerNode_GetIncrement(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t* increment);
PEAK_C_API PEAK_IntegerNode_GetIncrementType(
    PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE* incrementType);
PEAK_C_API PEAK_IntegerNode_GetValidValues(
    PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t* validValues, size_t* validValuesSize);
PEAK_C_API PEAK_IntegerNode_GetRepresentation(
    PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION* representation);
PEAK_C_API PEAK_IntegerNode_GetUnit(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char* unit, size_t* unitSize);
PEAK_C_API PEAK_IntegerNode_GetValue(
    PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, int64_t* value);
PEAK_C_API PEAK_IntegerNode_SetValue(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value);

PEAK_C_API PEAK_BooleanNode_ToNode(
    PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_BooleanNode_GetValue(
    PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_BOOL8* value);
PEAK_C_API PEAK_BooleanNode_SetValue(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value);

PEAK_C_API PEAK_CommandNode_ToNode(
    PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_CommandNode_GetIsDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_BOOL8* isDone);

PEAK_C_API PEAK_CommandNode_Execute(PEAK_COMMAND_NODE_HANDLE commandNodeHandle);
PEAK_C_API PEAK_CommandNode_WaitUntilDoneInfinite(PEAK_COMMAND_NODE_HANDLE commandNodeHandle);
PEAK_C_API PEAK_CommandNode_WaitUntilDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, uint64_t waitTimeout_ms);

PEAK_C_API PEAK_FloatNode_ToNode(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_FloatNode_GetMinimum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double* minimum);
PEAK_C_API PEAK_FloatNode_GetMaximum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double* maximum);
PEAK_C_API PEAK_FloatNode_GetIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double* increment);
PEAK_C_API PEAK_FloatNode_GetIncrementType(
    PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE* incrementType);
PEAK_C_API PEAK_FloatNode_GetValidValues(
    PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double* validValues, size_t* validValuesSize);
PEAK_C_API PEAK_FloatNode_GetRepresentation(
    PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION* representation);
PEAK_C_API PEAK_FloatNode_GetUnit(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char* unit, size_t* unitSize);
PEAK_C_API PEAK_FloatNode_GetDisplayNotation(
    PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION* displayNotation);
PEAK_C_API PEAK_FloatNode_GetDisplayPrecision(
    PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t* displayPrecision);
PEAK_C_API PEAK_FloatNode_GetHasConstantIncrement(
    PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8* hasConstantIncrement);
PEAK_C_API PEAK_FloatNode_GetValue(
    PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, double* value);
PEAK_C_API PEAK_FloatNode_SetValue(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double value);

PEAK_C_API PEAK_StringNode_ToNode(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_StringNode_GetMaximumLength(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t* maximumLength);
PEAK_C_API PEAK_StringNode_GetValue(PEAK_STRING_NODE_HANDLE stringNodeHandle,
    PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, char* value, size_t* valueSize);
PEAK_C_API PEAK_StringNode_SetValue(
    PEAK_STRING_NODE_HANDLE stringNodeHandle, const char* value, size_t valueSize);

PEAK_C_API PEAK_RegisterNode_ToNode(
    PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_RegisterNode_GetAddress(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t* address);
PEAK_C_API PEAK_RegisterNode_GetLength(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t* length);
PEAK_C_API PEAK_RegisterNode_Read(PEAK_REGISTER_NODE_HANDLE registerNodeHandle,
    PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, uint8_t* bytesToRead, size_t bytesToReadSize);
PEAK_C_API PEAK_RegisterNode_Write(
    PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t* bytesToWrite, size_t bytesToWriteSize);

PEAK_C_API PEAK_CategoryNode_ToNode(
    PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_CategoryNode_GetNumSubNodes(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t* numSubNodes);
PEAK_C_API PEAK_CategoryNode_GetSubNode(
    PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t index, PEAK_NODE_HANDLE* nodeHandle);

PEAK_C_API PEAK_EnumerationNode_ToNode(
    PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
PEAK_C_API PEAK_EnumerationNode_GetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
    PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
PEAK_C_API PEAK_EnumerationNode_SetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
    PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle);
PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(
    PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char* symbolicValue, size_t symbolicValueSize);
PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryByValue(
    PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value);

PEAK_C_API PEAK_EnumerationNode_GetHasEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
    const char* symbolicValue, size_t symbolicValueSize, PEAK_BOOL8* hasEntry);

PEAK_C_API PEAK_EnumerationNode_GetHasEntryByValue(
    PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value, PEAK_BOOL8* hasEntry);

PEAK_C_API PEAK_EnumerationNode_FindEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
    const char* symbolicValue, size_t symbolicValueSize,
    PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);

PEAK_C_API PEAK_EnumerationNode_FindEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
    int64_t value, PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);

PEAK_C_API PEAK_EnumerationNode_TryFindEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
    const char* symbolicValue, size_t symbolicValueSize,
    PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);

PEAK_C_API PEAK_EnumerationNode_TryFindEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
    int64_t value, PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);

PEAK_C_API PEAK_EnumerationNode_GetNumEntries(
    PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t* numEntries);

PEAK_C_API PEAK_EnumerationNode_GetEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t index,
    PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);

PEAK_C_API PEAK_EnumerationEntryNode_ToNode(
    PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE* nodeHandle);

PEAK_C_API PEAK_EnumerationEntryNode_GetIsSelfClearing(
    PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8* isSelfClearing);

PEAK_C_API PEAK_EnumerationEntryNode_GetSymbolicValue(
    PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char* symbolicValue, size_t* symbolicValueSize);

PEAK_C_API PEAK_EnumerationEntryNode_GetValue(
    PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t* value);

PEAK_C_API PEAK_Port_GetInfo(
    PEAK_PORT_HANDLE portHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info, size_t* infoSize);

PEAK_C_API PEAK_Port_GetID(PEAK_PORT_HANDLE portHandle, char* id, size_t* idSize);

PEAK_C_API PEAK_Port_GetName(PEAK_PORT_HANDLE portHandle, char* name, size_t* nameSize);

PEAK_C_API PEAK_Port_GetVendorName(PEAK_PORT_HANDLE portHandle, char* vendorName, size_t* vendorNameSize);

PEAK_C_API PEAK_Port_GetModelName(PEAK_PORT_HANDLE portHandle, char* modelName, size_t* modelNameSize);

PEAK_C_API PEAK_Port_GetVersion(PEAK_PORT_HANDLE portHandle, char* version, size_t* versionSize);

PEAK_C_API PEAK_Port_GetTLType(PEAK_PORT_HANDLE portHandle, char* tlType, size_t* tlTypeSize);

PEAK_C_API PEAK_Port_GetModuleName(PEAK_PORT_HANDLE portHandle, char* moduleName, size_t* moduleNameSize);
PEAK_C_API PEAK_Port_GetDataEndianness(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS* dataEndianness);
PEAK_C_API PEAK_Port_GetIsReadable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8* isReadable);
PEAK_C_API PEAK_Port_GetIsWritable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8* isWritable);
PEAK_C_API PEAK_Port_GetIsAvailable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8* isAvailable);
PEAK_C_API PEAK_Port_GetIsImplemented(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8* isImplemented);
PEAK_C_API PEAK_Port_Read(
    PEAK_PORT_HANDLE portHandle, uint64_t address, uint8_t* bytesToRead, size_t bytesToReadSize);
PEAK_C_API PEAK_Port_Write(
    PEAK_PORT_HANDLE portHandle, uint64_t address, const uint8_t* bytesToWrite, size_t bytesToWriteSize);
PEAK_C_API PEAK_Port_GetNumURLs(PEAK_PORT_HANDLE portHandle, size_t* numUrls);
PEAK_C_API PEAK_Port_GetURL(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE* portUrlHandle);

PEAK_C_API PEAK_PortURL_GetInfo(
    PEAK_PORT_URL_HANDLE portUrlHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_PortURL_GetURL(PEAK_PORT_URL_HANDLE portUrlHandle, char* url, size_t* urlSize);
PEAK_C_API PEAK_PortURL_GetScheme(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME* scheme);
PEAK_C_API PEAK_PortURL_GetFileName(PEAK_PORT_URL_HANDLE portUrlHandle, char* fileName, size_t* fileNameSize);
PEAK_C_API PEAK_PortURL_GetFileRegisterAddress(
    PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t* fileRegisterAddress);
PEAK_C_API PEAK_PortURL_GetFileSize(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t* fileSize);
PEAK_C_API PEAK_PortURL_GetFileSHA1Hash(
    PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t* fileSha1Hash, size_t* fileSha1HashSize);
PEAK_C_API PEAK_PortURL_GetFileVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileVersionMajor);
PEAK_C_API PEAK_PortURL_GetFileVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileVersionMinor);
PEAK_C_API PEAK_PortURL_GetFileVersionSubminor(
    PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileVersionSubminor);
PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMajor(
    PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileSchemaVersionMajor);
PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMinor(
    PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileSchemaVersionMinor);
PEAK_C_API PEAK_PortURL_GetParentPort(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_HANDLE* portHandle);

PEAK_C_API PEAK_EventSupportingModule_EnableEvents(
    PEAK_EVENT_SUPPORTING_MODULE_HANDLE eventSupportingModuleHandle, PEAK_EVENT_TYPE eventType,
    PEAK_EVENT_CONTROLLER_HANDLE* eventControllerHandle);

PEAK_C_API PEAK_EventController_GetInfo(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle,
    int32_t infoCommand, int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_EventController_GetNumEventsInQueue(
    PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t* numEventsInQueue);
PEAK_C_API PEAK_EventController_GetNumEventsFired(
    PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t* numEventsFired);
PEAK_C_API PEAK_EventController_GetEventMaxSize(
    PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t* eventMaxSize);
PEAK_C_API PEAK_EventController_GetEventDataMaxSize(
    PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t* eventDataMaxSize);
PEAK_C_API PEAK_EventController_GetControlledEventType(
    PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE* controlledEventType);
PEAK_C_API PEAK_EventController_WaitForEvent(
    PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t timeout_ms, PEAK_EVENT_HANDLE* eventHandle);

PEAK_C_API PEAK_EventController_KillWait(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle);
PEAK_C_API PEAK_EventController_FlushPendingKillWaits(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle);
PEAK_C_API PEAK_EventController_FlushEvents(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle);
PEAK_C_API PEAK_EventController_Destruct(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle);

PEAK_C_API PEAK_Event_GetInfo(
    PEAK_EVENT_HANDLE eventHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info, size_t* infoSize);
PEAK_C_API PEAK_Event_GetID(PEAK_EVENT_HANDLE eventHandle, uint64_t* id);
PEAK_C_API PEAK_Event_GetData(PEAK_EVENT_HANDLE eventHandle, uint8_t* data, size_t* dataSize);
PEAK_C_API PEAK_Event_GetType(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE* type);
PEAK_C_API PEAK_Event_GetRawData(PEAK_EVENT_HANDLE eventHandle, uint8_t* rawData, size_t* rawDataSize);
PEAK_C_API PEAK_Event_Destruct(PEAK_EVENT_HANDLE eventHandle);

PEAK_C_API PEAK_FirmwareUpdater_Construct(PEAK_FIRMWARE_UPDATER_HANDLE* firmwareUpdaterHandle);
PEAK_C_API PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(
    PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char* gufPath, size_t gufPathSize);
PEAK_C_API PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation(
    PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char* gufPath, size_t gufPathSize,
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle);
PEAK_C_API PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(
    PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t* numFirmwareUpdateInformation);
PEAK_C_API PEAK_FirmwareUpdater_GetFirmwareUpdateInformation(
    PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t index,
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE* firmwareUpdateInformationHandle);
PEAK_C_API PEAK_FirmwareUpdater_UpdateDevice(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle,
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle);
PEAK_C_API PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout(
    PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    uint64_t deviceResetDiscoveryTimeout_ms);
PEAK_C_API PEAK_FirmwareUpdater_Destruct(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle);

PEAK_C_API PEAK_FirmwareUpdateInformation_GetIsValid(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8* isValid);
PEAK_C_API PEAK_FirmwareUpdateInformation_GetFileName(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char* fileName, size_t* fileNameSize);
PEAK_C_API PEAK_FirmwareUpdateInformation_GetDescription(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char* description,
    size_t* descriptionSize);
PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersion(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char* version, size_t* versionSize);
PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char* versionExtractionPattern,
    size_t* versionExtractionPatternSize);
PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionStyle(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
    PEAK_FIRMWARE_UPDATE_VERSION_STYLE* versionStyle);
PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotes(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char* releaseNotes,
    size_t* releaseNotesSize);
PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char* releaseNotesUrl,
    size_t* releaseNotesUrlSize);
PEAK_C_API PEAK_FirmwareUpdateInformation_GetUserSetPersistence(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
    PEAK_FIRMWARE_UPDATE_PERSISTENCE* userSetPersistence);
PEAK_C_API PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
    PEAK_FIRMWARE_UPDATE_PERSISTENCE* sequencerSetPersistence);

PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Construct(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE* firmwareUpdateProgressObserverHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK callback, void* callbackContext,
    PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK callback, void* callbackContext,
    PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK callback, void* callbackContext,
    PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK callback, void* callbackContext,
    PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK callback, void* callbackContext,
    PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK callback, void* callbackContext,
    PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE* callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
    PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE callbackHandle);
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Destruct(
    PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle);

PEAK_C_API PEAK_FileAdapter_Construct(
    PEAK_NODE_MAP_HANDLE nodeMapHandle, const char* fileName, PEAK_FILE_ADAPTER_HANDLE* fileAdapterHandle);

PEAK_C_API PEAK_FileAdapter_Destruct(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle);

PEAK_C_API PEAK_FileAdapter_Read(
    PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, uint64_t size, uint64_t offset, uint8_t* data, uint64_t* dataSize);

PEAK_C_API PEAK_FileAdapter_Write(
    PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, const uint8_t* data, uint64_t size, uint64_t offset);

PEAK_C_API PEAK_FileAdapter_Delete(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle);

PEAK_C_API PEAK_FileAdapter_GetSize(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, uint64_t* size);
 

PEAK_C_API PEAK_FileAdapter_GetMaxSize(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, uint64_t* maxSize);
 
#    ifdef __cplusplus
} // extern "C"
#    endif
 
#else
#    ifdef __cplusplus
} // extern "C"
#    endif
 
#    include <peak/backend/peak_dynamic_loader.h>
#endif // !PEAK_DYNAMIC_LOADING