/* automatically generated by rust-bindgen 0.72.0 */

pub type __time_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timespec {
    pub tv_sec: __time_t,
    pub tv_nsec: __syscall_slong_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of timespec"][::std::mem::size_of::<timespec>() - 16usize];
    ["Alignment of timespec"][::std::mem::align_of::<timespec>() - 8usize];
    ["Offset of field: timespec::tv_sec"][::std::mem::offset_of!(timespec, tv_sec) - 0usize];
    ["Offset of field: timespec::tv_nsec"][::std::mem::offset_of!(timespec, tv_nsec) - 8usize];
};
pub const dv_error_category_DV_ERROR_CATEGORY_SUCCESS: dv_error_category = 0;
pub const dv_error_category_DV_ERROR_CATEGORY_RETRY: dv_error_category = 100;
pub const dv_error_category_DV_ERROR_CATEGORY_INVALID: dv_error_category = 200;
pub const dv_error_category_DV_ERROR_CATEGORY_SW_CLIENT_FATAL: dv_error_category = 300;
pub const dv_error_category_DV_ERROR_CATEGORY_SW_SERVER_FATAL: dv_error_category = 400;
pub const dv_error_category_DV_ERROR_CATEGORY_HW_FATAL: dv_error_category = 500;
pub type dv_error_category = ::std::os::raw::c_uint;
pub use self::dv_error_category as dv_error_category_t;
pub const dv_status_code_DV_ERROR_CATEGORY_SUCCESS_START: dv_status_code = 0;
pub const dv_status_code_DV_SUCCESS: dv_status_code = 0;
pub const dv_status_code_DV_ERROR_CATEGORY_SUCCESS_END: dv_status_code = 0;
pub const dv_status_code_DV_FAILURE_UNKOWN: dv_status_code = 1;
pub const dv_status_code_DV_ERROR_CATEGORY_RETRY_START: dv_status_code = 100;
pub const dv_status_code_DV_ENDPOINT_OUT_OF_MEMORY: dv_status_code = 100;
pub const dv_status_code_DV_ERROR_CATEGORY_RETRY_END: dv_status_code = 199;
pub const dv_status_code_DV_ERROR_CATEGORY_INVALID_START: dv_status_code = 200;
pub const dv_status_code_DV_RESOURCE_NOT_FOUND: dv_status_code = 200;
pub const dv_status_code_DV_INVALID_VALUE: dv_status_code = 201;
pub const dv_status_code_DV_INVALID_HOST_PTR: dv_status_code = 202;
pub const dv_status_code_DV_INVALID_OPERATION: dv_status_code = 203;
pub const dv_status_code_DV_OPERATION_NOT_PERMITTED: dv_status_code = 204;
pub const dv_status_code_DV_OPERATION_NOT_SUPPORTED: dv_status_code = 205;
pub const dv_status_code_DV_SESSION_UNIX_SOCKET_FILE_TOO_LONG: dv_status_code = 220;
pub const dv_status_code_DV_SESSION_INVALID_TCP_IPV4_ADDR: dv_status_code = 221;
pub const dv_status_code_DV_SESSION_INVALID_TCP_IPV4_PORT: dv_status_code = 222;
pub const dv_status_code_DV_SESSION_INVALID_HANDLE: dv_status_code = 223;
pub const dv_status_code_DV_ENDPOINT_INVALID_HANDLE: dv_status_code = 230;
pub const dv_status_code_DV_ENDPOINT_INVALID_PARAMS: dv_status_code = 231;
pub const dv_status_code_DV_ENDPOINT_NOT_FOUND: dv_status_code = 232;
pub const dv_status_code_DV_ENDPOINT_NOT_AVAILABLE: dv_status_code = 233;
pub const dv_status_code_DV_ENDPOINT_GROUP_INVALID: dv_status_code = 234;
pub const dv_status_code_DV_ENDPOINT_POWER_SWITCH_FAILURE: dv_status_code = 235;
pub const dv_status_code_DV_ENDPOINT_POWER_GATED: dv_status_code = 236;
pub const dv_status_code_DV_ENDPOINT_INVALID_POWER_STATE: dv_status_code = 237;
pub const dv_status_code_DV_ENDPOINT_GET_LIST_FAILED: dv_status_code = 238;
pub const dv_status_code_DV_ENDPOINT_GET_STATS_FAILED: dv_status_code = 239;
pub const dv_status_code_DV_MODEL_INVALID_PARAMS: dv_status_code = 240;
pub const dv_status_code_DV_MODEL_INVALID_HANDLE: dv_status_code = 241;
pub const dv_status_code_DV_MODEL_INVALID_MODEL_FILE: dv_status_code = 242;
pub const dv_status_code_DV_MODEL_PARSE_FAILURE: dv_status_code = 243;
pub const dv_status_code_DV_MODEL_UNSUPPORTED_VERSION: dv_status_code = 244;
pub const dv_status_code_DV_MODEL_CACHING_FAILURE: dv_status_code = 245;
pub const dv_status_code_DV_MODEL_CACHE_FETCH_FAILURE: dv_status_code = 246;
pub const dv_status_code_DV_MODEL_SET_LLM_CFG_PARAMS_FAILED: dv_status_code = 247;
pub const dv_status_code_DV_SOFT_RESET_FAILURE: dv_status_code = 248;
pub const dv_status_code_DV_SOFT_RESET_UNSUPPORTED: dv_status_code = 249;
pub const dv_status_code_DV_INFER_INVALID_SHM_BUFFERS: dv_status_code = 250;
pub const dv_status_code_DV_INFER_REQUEST_INVALID_HANDLE: dv_status_code = 251;
pub const dv_status_code_DV_FIRMWARE_VERSION_INVALID: dv_status_code = 252;
pub const dv_status_code_DV_MODEL_LOAD_SUBMITTED: dv_status_code = 253;
pub const dv_status_code_DV_MODEL_ALREADY_LOADED: dv_status_code = 254;
pub const dv_status_code_DV_MODEL_UNLOAD_SUBMITTED: dv_status_code = 255;
pub const dv_status_code_DV_MODEL_LOAD_SUBMIT_FAILED: dv_status_code = 256;
pub const dv_status_code_DV_MODEL_LOAD_ABORTED: dv_status_code = 257;
pub const dv_status_code_DV_MODEL_UNLOAD_SUBMIT_FAILED: dv_status_code = 258;
pub const dv_status_code_DV_ERROR_CATEGORY_INVALID_END: dv_status_code = 299;
pub const dv_status_code_DV_ERROR_CATEGORY_SW_CLIENT_FATAL_START: dv_status_code = 300;
pub const dv_status_code_DV_CLIENT_VERSION_MISMATCH: dv_status_code = 300;
pub const dv_status_code_DV_CONNECTION_ERROR: dv_status_code = 301;
pub const dv_status_code_DV_HIF_PUSH_FAILED: dv_status_code = 302;
pub const dv_status_code_DV_HIF_ERROR: dv_status_code = 303;
pub const dv_status_code_DV_HIF_TIMEOUT: dv_status_code = 304;
pub const dv_status_code_DV_HIF_POP_FAILED: dv_status_code = 305;
pub const dv_status_code_DV_HIF_DEVICE_IN_CONFIG: dv_status_code = 306;
pub const dv_status_code_DV_ERROR_CATEGORY_SW_CLIENT_FATAL_END: dv_status_code = 399;
pub const dv_status_code_DV_ERROR_CATEGORY_SW_SERVER_FATAL_START: dv_status_code = 400;
pub const dv_status_code_DV_HOST_OUT_OF_MEMORY: dv_status_code = 400;
pub const dv_status_code_DV_INTERNAL_ERROR: dv_status_code = 401;
pub const dv_status_code_DV_REQUEST_TIMEDOUT: dv_status_code = 402;
pub const dv_status_code_DV_SHMBUF_NOT_PERMITTED: dv_status_code = 403;
pub const dv_status_code_DV_REQUEST_SEND_FAILED: dv_status_code = 404;
pub const dv_status_code_DV_REQUEST_PROCESSING_FAILED: dv_status_code = 405;
pub const dv_status_code_DV_ERROR_CATEGORY_SW_SERVER_FATAL_END: dv_status_code = 499;
pub const dv_status_code_DV_ERROR_CATEGORY_HW_FATAL_START: dv_status_code = 500;
pub const dv_status_code_DV_ENDPOINT_DMA_FAILED: dv_status_code = 500;
pub const dv_status_code_DV_ENDPOINT_FIRMWARE_LOAD_FAILURE: dv_status_code = 501;
pub const dv_status_code_DV_ENDPOINT_FIRMWARE_BOOT_FAILURE: dv_status_code = 502;
pub const dv_status_code_DV_ENDPOINT_NO_FIRMWARE: dv_status_code = 503;
pub const dv_status_code_DV_ENDPOINT_NOT_REACHABLE: dv_status_code = 504;
pub const dv_status_code_DV_ENDPOINT_MODEL_BINDING_FAILURE: dv_status_code = 505;
pub const dv_status_code_DV_TENSOR_FREE_ERROR: dv_status_code = 506;
pub const dv_status_code_DV_MODEL_LOAD_FAILURE: dv_status_code = 520;
pub const dv_status_code_DV_MODEL_RELOAD_FAILURE: dv_status_code = 521;
pub const dv_status_code_DV_MODEL_UNLOAD_FAILURE: dv_status_code = 522;
pub const dv_status_code_DV_PARTIAL_SUCCESS: dv_status_code = 523;
pub const dv_status_code_DV_TENSOR_WRITE_FAILURE: dv_status_code = 541;
pub const dv_status_code_DV_TENSOR_READ_FAILURE: dv_status_code = 542;
pub const dv_status_code_DV_TENSOR_CREATE_FAILURE: dv_status_code = 543;
pub const dv_status_code_DV_TENSOR_ALLOCTAION_FAILURE: dv_status_code = 545;
pub const dv_status_code_DV_TENSOR_INTEGRITY_CHECK_FAILURE: dv_status_code = 546;
pub const dv_status_code_DV_PROXY_DEVICE_INIT_FAILURE: dv_status_code = 551;
pub const dv_status_code_DV_INFER_TIME_OUT: dv_status_code = 560;
pub const dv_status_code_DV_INFER_FAILURE: dv_status_code = 561;
pub const dv_status_code_DV_INFER_INVALID_INPUT: dv_status_code = 562;
pub const dv_status_code_DV_INFER_QUEUE_FULL: dv_status_code = 563;
pub const dv_status_code_DV_INFER_QUEUE_EMPTY: dv_status_code = 564;
pub const dv_status_code_DV_INFER_MODEL_NOT_FOUND: dv_status_code = 565;
pub const dv_status_code_DV_INFER_ABORTED: dv_status_code = 566;
pub const dv_status_code_DV_INFER_SUBMIT_FAILURE: dv_status_code = 567;
pub const dv_status_code_DV_INFER_TIME_OUT_THERMAL_RUNAWAY: dv_status_code = 568;
pub const dv_status_code_DV_ERROR_CATEGORY_HW_FATAL_END: dv_status_code = 599;
pub const dv_status_code_DV_CLIENT_TXRX_WRITE_FAILURE: dv_status_code = 600;
pub const dv_status_code_DV_CLIENT_TXRX_READ_FAILURE: dv_status_code = 601;
pub const dv_status_code_DV_CLIENT_TXRX_ASYNC_SEND_FAILURE: dv_status_code = 602;
pub const dv_status_code_DV_CLIENT_TXRX_FD_COUNT_MISMATCH: dv_status_code = 603;
pub const dv_status_code_DV_CLIENT_TXRX_DISCONNECT_ERROR: dv_status_code = 604;
pub const dv_status_code_DV_CLIENT_RECEIVED_UNKNOWN_RESPONSE: dv_status_code = 605;
pub const dv_status_code_DV_CLIENT_TO_TXRX_CONNECTION_ERROR: dv_status_code = 606;
pub const dv_status_code_DV_FLOW_CREATE_FAILED: dv_status_code = 700;
pub const dv_status_code_DV_FLOW_SUBMIT_FAILED: dv_status_code = 701;
pub const dv_status_code_DV_FLOW_ABORTED: dv_status_code = 702;
pub const dv_status_code_DV_CP_INDEX_ALLOC_FAILURE: dv_status_code = 800;
pub const dv_status_code_DV_MMIO_READ_FAIL: dv_status_code = 900;
pub const dv_status_code_DV_MMIO_WRITE_FAIL: dv_status_code = 901;
pub type dv_status_code = ::std::os::raw::c_uint;
pub use self::dv_status_code as dv_status_code_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_infer_request_handle {
    _unused: [u8; 0],
}
pub type dv_infer_request_handle_t = dv_infer_request_handle;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_model_handle {
    _unused: [u8; 0],
}
pub type dv_model_handle_t = dv_model_handle;
#[doc = "< unix domain socket"]
pub const DV_SESSION_SOCKET_TYPE_DV_SESSION_SOCKET_TYPE_UNIX: DV_SESSION_SOCKET_TYPE = 0;
#[doc = "< tcp ipv4 socket"]
pub const DV_SESSION_SOCKET_TYPE_DV_SESSION_SOCKET_TYPE_TCPIPv4: DV_SESSION_SOCKET_TYPE = 1;
#[doc = " DV session socket type"]
pub type DV_SESSION_SOCKET_TYPE = ::std::os::raw::c_uint;
#[doc = " DV session socket type"]
pub use self::DV_SESSION_SOCKET_TYPE as dv_session_socket_type_t;
#[doc = "< host and dv connected via pcie interface"]
pub const DV_ENDPOINT_HOST_INTERFACE_DV_ENDPOINT_HOST_INTERFACE_PCIE: DV_ENDPOINT_HOST_INTERFACE =
    1;
#[doc = "< host and dv connected via usb interface"]
pub const DV_ENDPOINT_HOST_INTERFACE_DV_ENDPOINT_HOST_INTERFACE_USB: DV_ENDPOINT_HOST_INTERFACE = 2;
#[doc = " DV Endpoint to host communication interface"]
pub type DV_ENDPOINT_HOST_INTERFACE = ::std::os::raw::c_uint;
#[doc = " DV Endpoint to host communication interface"]
pub use self::DV_ENDPOINT_HOST_INTERFACE as dv_endpoint_host_interface_t;
#[doc = "< default group for all the endpoint(s)\nconnected to inference proxy server"]
pub const DV_ENDPOINT_DEFAULT_GROUP_DV_ENDPOINT_DEFAULT_GROUP_ALL: DV_ENDPOINT_DEFAULT_GROUP = 0;
#[doc = "< default group for all the pcie endpoint(s) connected to inference\nproxy server"]
pub const DV_ENDPOINT_DEFAULT_GROUP_DV_ENDPOINT_DEFAULT_GROUP_PCIE: DV_ENDPOINT_DEFAULT_GROUP = 1;
#[doc = "< default group for all the usb endpoint(s) connected to inference\nproxy server"]
pub const DV_ENDPOINT_DEFAULT_GROUP_DV_ENDPOINT_DEFAULT_GROUP_USB: DV_ENDPOINT_DEFAULT_GROUP = 2;
pub type DV_ENDPOINT_DEFAULT_GROUP = ::std::os::raw::c_uint;
pub use self::DV_ENDPOINT_DEFAULT_GROUP as dv_endpoint_default_group_t;
#[doc = "< endpoint is in init state"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_INIT: DV_ENDPOINT_STATE = 0;
#[doc = "< endpoint is in idle state"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_IDLE: DV_ENDPOINT_STATE = 1;
#[doc = "< endpoint is in active state"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_ACTIVE: DV_ENDPOINT_STATE = 2;
#[doc = "< endpoint is operating at reduced frequency"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_ACTIVE_SLOW: DV_ENDPOINT_STATE = 3;
#[doc = "< endpoint is operating at reduced frequency"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_ACTIVE_BOOSTED: DV_ENDPOINT_STATE = 4;
#[doc = "< endpoint is in thermal Inactive state"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_THERMAL_INACTIVE: DV_ENDPOINT_STATE = 5;
#[doc = "< endpoint is in unown thermal state"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_THERMAL_UNKNOWN: DV_ENDPOINT_STATE = 6;
#[doc = "< endpoint is in Inactive state"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_INACTIVE: DV_ENDPOINT_STATE = 7;
#[doc = "< endpoint is in faulty state"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_FAULT: DV_ENDPOINT_STATE = 8;
#[doc = "< [unsupported]"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_BAD_INTERFACE: DV_ENDPOINT_STATE = 1001;
#[doc = "< [unsupported]"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_RECOVERY: DV_ENDPOINT_STATE = 1003;
#[doc = "< [unsupported]"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_DEAD: DV_ENDPOINT_STATE = 1004;
#[doc = "< [unsupported]"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_DRAIN: DV_ENDPOINT_STATE = 1005;
#[doc = "< [unsupported]"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_POWER_GATED: DV_ENDPOINT_STATE = 1006;
#[doc = "< [unsupported]"]
pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_CLOSED: DV_ENDPOINT_STATE = 1007;
#[doc = " Endpoint state"]
pub type DV_ENDPOINT_STATE = ::std::os::raw::c_uint;
#[doc = " Endpoint state"]
pub use self::DV_ENDPOINT_STATE as dv_endpoint_state_t;
#[doc = "< endpoint is in L0 state"]
pub const DV_ENDPOINT_POWER_STATE_DV_POWER_STATE_L0: DV_ENDPOINT_POWER_STATE = 0;
#[doc = "< endpoint is in L1 state"]
pub const DV_ENDPOINT_POWER_STATE_DV_POWER_STATE_L1: DV_ENDPOINT_POWER_STATE = 1;
#[doc = "< endpoint is in L1A state"]
pub const DV_ENDPOINT_POWER_STATE_DV_POWER_STATE_L1A: DV_ENDPOINT_POWER_STATE = 2;
#[doc = "< endpoint is in L2 state"]
pub const DV_ENDPOINT_POWER_STATE_DV_POWER_STATE_L2: DV_ENDPOINT_POWER_STATE = 3;
#[doc = " Endpoint Power State [currently unsupported]"]
pub type DV_ENDPOINT_POWER_STATE = ::std::os::raw::c_uint;
#[doc = " Endpoint Power State [currently unsupported]"]
pub use self::DV_ENDPOINT_POWER_STATE as dv_endpoint_power_state_t;
#[doc = "< endpoint group type none"]
pub const DV_ENDPOINT_GROUP_TYPE_DV_ENDPOINT_GROUP_TYPE_NONE: DV_ENDPOINT_GROUP_TYPE = 0;
#[doc = "< endpoint group type all"]
pub const DV_ENDPOINT_GROUP_TYPE_DV_ENDPOINT_GROUP_TYPE_ALL: DV_ENDPOINT_GROUP_TYPE = 1;
#[doc = "< endpoint group type pcie"]
pub const DV_ENDPOINT_GROUP_TYPE_DV_ENDPOINT_GROUP_TYPE_PCIE: DV_ENDPOINT_GROUP_TYPE = 2;
#[doc = "< endpoint group type usb"]
pub const DV_ENDPOINT_GROUP_TYPE_DV_ENDPOINT_GROUP_TYPE_USB: DV_ENDPOINT_GROUP_TYPE = 3;
#[doc = "< endpoint group type custom"]
pub const DV_ENDPOINT_GROUP_TYPE_DV_ENDPOINT_GROUP_TYPE_CUSTOM: DV_ENDPOINT_GROUP_TYPE = 4;
pub type DV_ENDPOINT_GROUP_TYPE = ::std::os::raw::c_uint;
pub use self::DV_ENDPOINT_GROUP_TYPE as dv_endpoint_group_type_t;
#[doc = "< represents classification type of network"]
pub const DV_LAYER_OUTPUT_TYPE_DV_LAYER_OUTPUT_TYPE_CLASSIFICATION: DV_LAYER_OUTPUT_TYPE = 0;
#[doc = "< represents detection type of network"]
pub const DV_LAYER_OUTPUT_TYPE_DV_LAYER_OUTPUT_TYPE_DETECTION: DV_LAYER_OUTPUT_TYPE = 1;
#[doc = "< represents semantic segmentation type of network"]
pub const DV_LAYER_OUTPUT_TYPE_DV_LAYER_OUTPUT_TYPE_SEMANTIC_SEGMENTATION: DV_LAYER_OUTPUT_TYPE = 2;
#[doc = "< represents all other network types which can't be determined"]
pub const DV_LAYER_OUTPUT_TYPE_DV_LAYER_OUTPUT_TYPE_RAW: DV_LAYER_OUTPUT_TYPE = 3;
#[doc = " Model Network type"]
pub type DV_LAYER_OUTPUT_TYPE = ::std::os::raw::c_uint;
#[doc = " Model Network type"]
pub use self::DV_LAYER_OUTPUT_TYPE as dv_layer_output_type_t;
#[doc = "< model priority low"]
pub const DV_MODEL_PRIORITY_LEVEL_DV_MODEL_PRIORITY_LEVEL_LOW: DV_MODEL_PRIORITY_LEVEL = 0;
#[doc = "< model priority medium"]
pub const DV_MODEL_PRIORITY_LEVEL_DV_MODEL_PRIORITY_LEVEL_MEDIUM: DV_MODEL_PRIORITY_LEVEL = 1;
#[doc = "< model priority default"]
pub const DV_MODEL_PRIORITY_LEVEL_DV_MODEL_PRIORITY_LEVEL_DEFAULT: DV_MODEL_PRIORITY_LEVEL = 1;
#[doc = "< model priority high"]
pub const DV_MODEL_PRIORITY_LEVEL_DV_MODEL_PRIORITY_LEVEL_HIGH: DV_MODEL_PRIORITY_LEVEL = 2;
#[doc = " Priority level of model"]
pub type DV_MODEL_PRIORITY_LEVEL = ::std::os::raw::c_uint;
#[doc = " Priority level of model"]
pub use self::DV_MODEL_PRIORITY_LEVEL as dv_model_priority_level_t;
#[doc = "< Inference is in queued state"]
pub const DV_INFERENCE_STATUS_DV_INFERENCE_STATUS_QUEUED: DV_INFERENCE_STATUS = 0;
#[doc = "< Inference is in running/executing state"]
pub const DV_INFERENCE_STATUS_DV_INFERENCE_STATUS_RUNNING: DV_INFERENCE_STATUS = 1;
#[doc = "< Inference is in completed state"]
pub const DV_INFERENCE_STATUS_DV_INFERENCE_STATUS_COMPLETED: DV_INFERENCE_STATUS = 2;
#[doc = "< Inference is in failed state"]
pub const DV_INFERENCE_STATUS_DV_INFERENCE_STATUS_FAILED: DV_INFERENCE_STATUS = 4;
#[doc = "< Inference information is not available"]
pub const DV_INFERENCE_STATUS_DV_INFERENCE_STATUS_UNKNOWN: DV_INFERENCE_STATUS = 5;
#[doc = " Inference status"]
pub type DV_INFERENCE_STATUS = ::std::os::raw::c_uint;
#[doc = " Inference status"]
pub use self::DV_INFERENCE_STATUS as dv_inference_status_t;
#[doc = "< represents blob backed by raw pointer"]
pub const DV_BLOB_TYPE_DV_BLOB_TYPE_RAW_POINTER: DV_BLOB_TYPE = 0;
#[doc = "< represents blob backed by registered shared memory descriptor"]
pub const DV_BLOB_TYPE_DV_BLOB_TYPE_SHM_DESCRIPTOR: DV_BLOB_TYPE = 1;
#[doc = "< represents blob backed by non-registered file descriptor"]
pub const DV_BLOB_TYPE_DV_BLOB_TYPE_FD: DV_BLOB_TYPE = 2;
#[doc = " Blob types"]
pub type DV_BLOB_TYPE = ::std::os::raw::c_uint;
#[doc = " Blob types"]
pub use self::DV_BLOB_TYPE as dv_blob_type_t;
pub const DV_PRODUCT_TYPE_INVALID_PRODUCT: DV_PRODUCT_TYPE = -1;
pub const DV_PRODUCT_TYPE_PROXY: DV_PRODUCT_TYPE = 0;
pub const DV_PRODUCT_TYPE_PCI_DRIVER: DV_PRODUCT_TYPE = 1;
pub const DV_PRODUCT_TYPE_FIRMWARE: DV_PRODUCT_TYPE = 2;
pub const DV_PRODUCT_TYPE_CNN_MODEL: DV_PRODUCT_TYPE = 3;
pub const DV_PRODUCT_TYPE_LLM_MODEL: DV_PRODUCT_TYPE = 4;
pub const DV_PRODUCT_TYPE_CLIENT_LIB: DV_PRODUCT_TYPE = 5;
pub const DV_PRODUCT_TYPE_SYSAPI: DV_PRODUCT_TYPE = 6;
pub type DV_PRODUCT_TYPE = ::std::os::raw::c_int;
pub use self::DV_PRODUCT_TYPE as dv_product_type_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_version {
    pub major: u8,
    pub minor: u8,
    pub patch: u8,
    pub patch_minor: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_version"][::std::mem::size_of::<dv_version>() - 4usize];
    ["Alignment of dv_version"][::std::mem::align_of::<dv_version>() - 1usize];
    ["Offset of field: dv_version::major"][::std::mem::offset_of!(dv_version, major) - 0usize];
    ["Offset of field: dv_version::minor"][::std::mem::offset_of!(dv_version, minor) - 1usize];
    ["Offset of field: dv_version::patch"][::std::mem::offset_of!(dv_version, patch) - 2usize];
    ["Offset of field: dv_version::patch_minor"]
        [::std::mem::offset_of!(dv_version, patch_minor) - 3usize];
};
pub type dv_version_t = dv_version;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_product_version {
    pub product_type: dv_product_type_t,
    pub product_version: dv_version_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_product_version"][::std::mem::size_of::<dv_product_version>() - 8usize];
    ["Alignment of dv_product_version"][::std::mem::align_of::<dv_product_version>() - 4usize];
    ["Offset of field: dv_product_version::product_type"]
        [::std::mem::offset_of!(dv_product_version, product_type) - 0usize];
    ["Offset of field: dv_product_version::product_version"]
        [::std::mem::offset_of!(dv_product_version, product_version) - 4usize];
};
pub type dv_product_version_t = dv_product_version;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_blob {
    #[doc = "< blob handle (raw pointer or shared file descriptor returned\nby server)"]
    pub handle: *mut ::std::os::raw::c_void,
    #[doc = "< blob offset"]
    pub offset: u64,
    #[doc = "< blob size"]
    pub size: u64,
    #[doc = "< blob type as represented in enum DV_BLOB_TYPE"]
    pub blob_type: dv_blob_type_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_blob"][::std::mem::size_of::<dv_blob>() - 32usize];
    ["Alignment of dv_blob"][::std::mem::align_of::<dv_blob>() - 8usize];
    ["Offset of field: dv_blob::handle"][::std::mem::offset_of!(dv_blob, handle) - 0usize];
    ["Offset of field: dv_blob::offset"][::std::mem::offset_of!(dv_blob, offset) - 8usize];
    ["Offset of field: dv_blob::size"][::std::mem::offset_of!(dv_blob, size) - 16usize];
    ["Offset of field: dv_blob::blob_type"][::std::mem::offset_of!(dv_blob, blob_type) - 24usize];
};
pub type dv_blob_t = dv_blob;
#[doc = " Default session wide parameters that are to be passed to dv_session_create_via_*_with_options"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_session_options {
    #[doc = "< global default timeout"]
    pub timeout_ms: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_session_options"][::std::mem::size_of::<dv_session_options>() - 4usize];
    ["Alignment of dv_session_options"][::std::mem::align_of::<dv_session_options>() - 4usize];
    ["Offset of field: dv_session_options::timeout_ms"]
        [::std::mem::offset_of!(dv_session_options, timeout_ms) - 0usize];
};
#[doc = " Default session wide parameters that are to be passed to dv_session_create_via_*_with_options"]
pub type dv_session_options_t = dv_session_options;
#[doc = " Session object with parameters"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_session {
    #[doc = "< session private handle, managed by client library"]
    pub handle: *mut ::std::os::raw::c_void,
    #[doc = "< NULL terminated socket connection string"]
    pub socket_str: *mut ::std::os::raw::c_char,
    #[doc = "< socket types: Unix domain socket/TCPIPv4"]
    pub socket_type: dv_session_socket_type_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_session"][::std::mem::size_of::<dv_session>() - 24usize];
    ["Alignment of dv_session"][::std::mem::align_of::<dv_session>() - 8usize];
    ["Offset of field: dv_session::handle"][::std::mem::offset_of!(dv_session, handle) - 0usize];
    ["Offset of field: dv_session::socket_str"]
        [::std::mem::offset_of!(dv_session, socket_str) - 8usize];
    ["Offset of field: dv_session::socket_type"]
        [::std::mem::offset_of!(dv_session, socket_type) - 16usize];
};
#[doc = " Session object with parameters"]
pub type dv_session_t = dv_session;
#[doc = " Shared memory decriptor generated after registering fd to server"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_shm_descriptor {
    #[doc = "< shared mem handle, managed by client library"]
    pub handle: *mut ::std::os::raw::c_void,
    #[doc = "< session handle on which shared memory is registered"]
    pub session: *mut dv_session_t,
    #[doc = "< file fd for which shared memory is registered"]
    pub fd: ::std::os::raw::c_int,
    #[doc = "< size to map"]
    pub size: usize,
    #[doc = "< offset in file"]
    pub offset: usize,
    #[doc = "< type of fd shared (reserved)"]
    pub fd_type: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_shm_descriptor"][::std::mem::size_of::<dv_shm_descriptor>() - 48usize];
    ["Alignment of dv_shm_descriptor"][::std::mem::align_of::<dv_shm_descriptor>() - 8usize];
    ["Offset of field: dv_shm_descriptor::handle"]
        [::std::mem::offset_of!(dv_shm_descriptor, handle) - 0usize];
    ["Offset of field: dv_shm_descriptor::session"]
        [::std::mem::offset_of!(dv_shm_descriptor, session) - 8usize];
    ["Offset of field: dv_shm_descriptor::fd"]
        [::std::mem::offset_of!(dv_shm_descriptor, fd) - 16usize];
    ["Offset of field: dv_shm_descriptor::size"]
        [::std::mem::offset_of!(dv_shm_descriptor, size) - 24usize];
    ["Offset of field: dv_shm_descriptor::offset"]
        [::std::mem::offset_of!(dv_shm_descriptor, offset) - 32usize];
    ["Offset of field: dv_shm_descriptor::fd_type"]
        [::std::mem::offset_of!(dv_shm_descriptor, fd_type) - 40usize];
};
#[doc = " Shared memory decriptor generated after registering fd to server"]
pub type dv_shm_descriptor_t = dv_shm_descriptor;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_endpoint_chip_info {
    #[doc = "< dv chip id"]
    pub id: *mut ::std::os::raw::c_char,
    #[doc = "< dv chip revision"]
    pub rev: *mut ::std::os::raw::c_char,
    #[doc = "< dv chip control processor count"]
    pub control_processor_count: ::std::os::raw::c_int,
    #[doc = "< dv chip neural processor count"]
    pub neural_processor_count: ::std::os::raw::c_int,
    #[doc = "< dv chip internal L2 memory size in bytes"]
    pub l2_memory_size: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_endpoint_chip_info"][::std::mem::size_of::<dv_endpoint_chip_info>() - 32usize];
    ["Alignment of dv_endpoint_chip_info"]
        [::std::mem::align_of::<dv_endpoint_chip_info>() - 8usize];
    ["Offset of field: dv_endpoint_chip_info::id"]
        [::std::mem::offset_of!(dv_endpoint_chip_info, id) - 0usize];
    ["Offset of field: dv_endpoint_chip_info::rev"]
        [::std::mem::offset_of!(dv_endpoint_chip_info, rev) - 8usize];
    ["Offset of field: dv_endpoint_chip_info::control_processor_count"]
        [::std::mem::offset_of!(dv_endpoint_chip_info, control_processor_count) - 16usize];
    ["Offset of field: dv_endpoint_chip_info::neural_processor_count"]
        [::std::mem::offset_of!(dv_endpoint_chip_info, neural_processor_count) - 20usize];
    ["Offset of field: dv_endpoint_chip_info::l2_memory_size"]
        [::std::mem::offset_of!(dv_endpoint_chip_info, l2_memory_size) - 24usize];
};
pub type dv_endpoint_chip_info_t = dv_endpoint_chip_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_endpoint_dram_info {
    #[doc = "< dv dram vendor id"]
    pub vendor_id: u32,
    #[doc = "< dv dram vendor name"]
    pub vendor_name: *mut ::std::os::raw::c_char,
    #[doc = "< dv dram memory size in bytes"]
    pub size: u32,
    #[doc = "< dv dram revision id 1"]
    pub rev_id1: u8,
    #[doc = "< dv dram revision id 2"]
    pub rev_id2: u8,
    #[doc = "< dv dram density"]
    pub density: u8,
    #[doc = "< dv dram io width"]
    pub io_width: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_endpoint_dram_info"][::std::mem::size_of::<dv_endpoint_dram_info>() - 24usize];
    ["Alignment of dv_endpoint_dram_info"]
        [::std::mem::align_of::<dv_endpoint_dram_info>() - 8usize];
    ["Offset of field: dv_endpoint_dram_info::vendor_id"]
        [::std::mem::offset_of!(dv_endpoint_dram_info, vendor_id) - 0usize];
    ["Offset of field: dv_endpoint_dram_info::vendor_name"]
        [::std::mem::offset_of!(dv_endpoint_dram_info, vendor_name) - 8usize];
    ["Offset of field: dv_endpoint_dram_info::size"]
        [::std::mem::offset_of!(dv_endpoint_dram_info, size) - 16usize];
    ["Offset of field: dv_endpoint_dram_info::rev_id1"]
        [::std::mem::offset_of!(dv_endpoint_dram_info, rev_id1) - 20usize];
    ["Offset of field: dv_endpoint_dram_info::rev_id2"]
        [::std::mem::offset_of!(dv_endpoint_dram_info, rev_id2) - 21usize];
    ["Offset of field: dv_endpoint_dram_info::density"]
        [::std::mem::offset_of!(dv_endpoint_dram_info, density) - 22usize];
    ["Offset of field: dv_endpoint_dram_info::io_width"]
        [::std::mem::offset_of!(dv_endpoint_dram_info, io_width) - 23usize];
};
pub type dv_endpoint_dram_info_t = dv_endpoint_dram_info;
#[doc = " DV Endpoint interface information"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dv_endpoint_iface_info {
    #[doc = "< dv module physical interface (pcie, usb) with host"]
    pub type_: dv_endpoint_host_interface_t,
    #[doc = "< host interface bus number on which dv device is connected"]
    pub bus_num: ::std::os::raw::c_int,
    #[doc = "< host interface device number on which dv device is\nconnected"]
    pub device_num: ::std::os::raw::c_int,
    pub sysfs_path: dv_endpoint_iface_info__bindgen_ty_1,
    #[doc = "< port on which device is connected"]
    pub port_num: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dv_endpoint_iface_info__bindgen_ty_1 {
    #[doc = "< \\since r5.3 path to the pcie sysfs entry for a PCIE\ninterface device"]
    pub pcie_dir: *mut ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_endpoint_iface_info__bindgen_ty_1"]
        [::std::mem::size_of::<dv_endpoint_iface_info__bindgen_ty_1>() - 8usize];
    ["Alignment of dv_endpoint_iface_info__bindgen_ty_1"]
        [::std::mem::align_of::<dv_endpoint_iface_info__bindgen_ty_1>() - 8usize];
    ["Offset of field: dv_endpoint_iface_info__bindgen_ty_1::pcie_dir"]
        [::std::mem::offset_of!(dv_endpoint_iface_info__bindgen_ty_1, pcie_dir) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_endpoint_iface_info"][::std::mem::size_of::<dv_endpoint_iface_info>() - 32usize];
    ["Alignment of dv_endpoint_iface_info"]
        [::std::mem::align_of::<dv_endpoint_iface_info>() - 8usize];
    ["Offset of field: dv_endpoint_iface_info::type_"]
        [::std::mem::offset_of!(dv_endpoint_iface_info, type_) - 0usize];
    ["Offset of field: dv_endpoint_iface_info::bus_num"]
        [::std::mem::offset_of!(dv_endpoint_iface_info, bus_num) - 4usize];
    ["Offset of field: dv_endpoint_iface_info::device_num"]
        [::std::mem::offset_of!(dv_endpoint_iface_info, device_num) - 8usize];
    ["Offset of field: dv_endpoint_iface_info::sysfs_path"]
        [::std::mem::offset_of!(dv_endpoint_iface_info, sysfs_path) - 16usize];
    ["Offset of field: dv_endpoint_iface_info::port_num"]
        [::std::mem::offset_of!(dv_endpoint_iface_info, port_num) - 24usize];
};
#[doc = " DV Endpoint interface information"]
pub type dv_endpoint_iface_info_t = dv_endpoint_iface_info;
#[doc = " DV Endpoint information"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_endpoint_info {
    #[doc = "< endpoint device id"]
    pub device_id: u32,
    #[doc = "< endpoint vendor id"]
    pub vendor_id: u32,
    #[doc = "< endpoint chip information"]
    pub chip: *mut dv_endpoint_chip_info_t,
    #[doc = "< endpoint external dram information"]
    pub dram: *mut dv_endpoint_dram_info_t,
    #[doc = "< endpoint interface information"]
    pub iface: *mut dv_endpoint_iface_info_t,
    #[doc = "< physical module name connected to server"]
    pub module_name: *mut ::std::os::raw::c_char,
    #[doc = "< [unused]"]
    pub gpio0: u32,
    #[doc = "< [unused]"]
    pub gpio1: u32,
    #[doc = "< used to uniquely identify the chip"]
    pub device_uid: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_endpoint_info"][::std::mem::size_of::<dv_endpoint_info>() - 56usize];
    ["Alignment of dv_endpoint_info"][::std::mem::align_of::<dv_endpoint_info>() - 8usize];
    ["Offset of field: dv_endpoint_info::device_id"]
        [::std::mem::offset_of!(dv_endpoint_info, device_id) - 0usize];
    ["Offset of field: dv_endpoint_info::vendor_id"]
        [::std::mem::offset_of!(dv_endpoint_info, vendor_id) - 4usize];
    ["Offset of field: dv_endpoint_info::chip"]
        [::std::mem::offset_of!(dv_endpoint_info, chip) - 8usize];
    ["Offset of field: dv_endpoint_info::dram"]
        [::std::mem::offset_of!(dv_endpoint_info, dram) - 16usize];
    ["Offset of field: dv_endpoint_info::iface"]
        [::std::mem::offset_of!(dv_endpoint_info, iface) - 24usize];
    ["Offset of field: dv_endpoint_info::module_name"]
        [::std::mem::offset_of!(dv_endpoint_info, module_name) - 32usize];
    ["Offset of field: dv_endpoint_info::gpio0"]
        [::std::mem::offset_of!(dv_endpoint_info, gpio0) - 40usize];
    ["Offset of field: dv_endpoint_info::gpio1"]
        [::std::mem::offset_of!(dv_endpoint_info, gpio1) - 44usize];
    ["Offset of field: dv_endpoint_info::device_uid"]
        [::std::mem::offset_of!(dv_endpoint_info, device_uid) - 48usize];
};
#[doc = " DV Endpoint information"]
pub type dv_endpoint_info_t = dv_endpoint_info;
#[doc = " Endpoint/Endpoint Group object"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_endpoint {
    #[doc = "< endpoint private handle, managed by client library"]
    pub handle: *mut ::std::os::raw::c_void,
    #[doc = "< session handle on which endpoint is queried"]
    pub session: *mut dv_session_t,
    #[doc = "< number of endpoints in the group"]
    pub num_ep: ::std::os::raw::c_int,
    #[doc = "< endpoint group type"]
    pub grp_type: dv_endpoint_group_type_t,
    #[doc = "< list of configuration for all the\nendpoint(s) in the group"]
    pub ep_info_list: *mut *mut dv_endpoint_info_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_endpoint"][::std::mem::size_of::<dv_endpoint>() - 32usize];
    ["Alignment of dv_endpoint"][::std::mem::align_of::<dv_endpoint>() - 8usize];
    ["Offset of field: dv_endpoint::handle"][::std::mem::offset_of!(dv_endpoint, handle) - 0usize];
    ["Offset of field: dv_endpoint::session"]
        [::std::mem::offset_of!(dv_endpoint, session) - 8usize];
    ["Offset of field: dv_endpoint::num_ep"][::std::mem::offset_of!(dv_endpoint, num_ep) - 16usize];
    ["Offset of field: dv_endpoint::grp_type"]
        [::std::mem::offset_of!(dv_endpoint, grp_type) - 20usize];
    ["Offset of field: dv_endpoint::ep_info_list"]
        [::std::mem::offset_of!(dv_endpoint, ep_info_list) - 24usize];
};
#[doc = " Endpoint/Endpoint Group object"]
pub type dv_endpoint_t = dv_endpoint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_endpoint_dram_statistics {
    #[doc = "< endpoint handle"]
    pub ep: *mut dv_endpoint_t,
    #[doc = "< endpoint dram size in bytes"]
    pub ep_total_dram_size: u64,
    #[doc = "< endpoint dram memory occupied in bytes"]
    pub ep_total_dram_occupancy_size: u64,
    #[doc = "< endpoint dram memory free in bytes"]
    pub ep_total_free_size: u64,
    #[doc = "< endpoint dram reserved memory in bytes for firmware"]
    pub ep_total_reserved_occupancy_size: u64,
    #[doc = "< endpoint dram memory occupied by all the active model artefacts in bytes"]
    pub ep_total_model_occupancy_size: u64,
    #[doc = "< endpoint dram memory occupied by all the active model tensors in bytes"]
    pub ep_total_tensor_occupancy_size: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_endpoint_dram_statistics"]
        [::std::mem::size_of::<dv_endpoint_dram_statistics>() - 56usize];
    ["Alignment of dv_endpoint_dram_statistics"]
        [::std::mem::align_of::<dv_endpoint_dram_statistics>() - 8usize];
    ["Offset of field: dv_endpoint_dram_statistics::ep"]
        [::std::mem::offset_of!(dv_endpoint_dram_statistics, ep) - 0usize];
    ["Offset of field: dv_endpoint_dram_statistics::ep_total_dram_size"]
        [::std::mem::offset_of!(dv_endpoint_dram_statistics, ep_total_dram_size) - 8usize];
    ["Offset of field: dv_endpoint_dram_statistics::ep_total_dram_occupancy_size"][::std::mem::offset_of!(
        dv_endpoint_dram_statistics,
        ep_total_dram_occupancy_size
    ) - 16usize];
    ["Offset of field: dv_endpoint_dram_statistics::ep_total_free_size"]
        [::std::mem::offset_of!(dv_endpoint_dram_statistics, ep_total_free_size) - 24usize];
    ["Offset of field: dv_endpoint_dram_statistics::ep_total_reserved_occupancy_size"][::std::mem::offset_of!(
        dv_endpoint_dram_statistics,
        ep_total_reserved_occupancy_size
    ) - 32usize];
    ["Offset of field: dv_endpoint_dram_statistics::ep_total_model_occupancy_size"][::std::mem::offset_of!(
        dv_endpoint_dram_statistics,
        ep_total_model_occupancy_size
    ) - 40usize];
    ["Offset of field: dv_endpoint_dram_statistics::ep_total_tensor_occupancy_size"][::std::mem::offset_of!(
        dv_endpoint_dram_statistics,
        ep_total_tensor_occupancy_size
    ) - 48usize];
};
pub type dv_endpoint_dram_statistics_t = dv_endpoint_dram_statistics;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_inference_queue_statistics {
    #[doc = "< Number of inference queue slots occupied with inference request for the endpoint"]
    pub occupancy_count: ::std::os::raw::c_int,
    #[doc = "< length of the inference queue for the endpoint"]
    pub length: ::std::os::raw::c_int,
    #[doc = "< waiting time in mili secs for the new inference request to get picked up by endpoint"]
    pub wait_time: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_inference_queue_statistics"]
        [::std::mem::size_of::<dv_inference_queue_statistics>() - 12usize];
    ["Alignment of dv_inference_queue_statistics"]
        [::std::mem::align_of::<dv_inference_queue_statistics>() - 4usize];
    ["Offset of field: dv_inference_queue_statistics::occupancy_count"]
        [::std::mem::offset_of!(dv_inference_queue_statistics, occupancy_count) - 0usize];
    ["Offset of field: dv_inference_queue_statistics::length"]
        [::std::mem::offset_of!(dv_inference_queue_statistics, length) - 4usize];
    ["Offset of field: dv_inference_queue_statistics::wait_time"]
        [::std::mem::offset_of!(dv_inference_queue_statistics, wait_time) - 8usize];
};
pub type dv_inference_queue_statistics_t = dv_inference_queue_statistics;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_model_statistics {
    #[doc = "< model handle"]
    pub model: u32,
    #[doc = "< number for active model input tensor(s) present in an endpoint"]
    pub active_input_tensors_count: u32,
    #[doc = "< number for active model output tensor(s) present in an endpoint"]
    pub active_output_tensors_count: u32,
    #[doc = "< number for active model inference request queued in an endpoint"]
    pub active_inferences_count: u32,
    #[doc = "< total endpoint dram occupancy in bytes by model artefacts"]
    pub model_total_dram_occupancy_size: u32,
    #[doc = "< total endpoint dram occupancy in bytes by model input tensors"]
    pub model_total_input_tensor_occupancy_size: u32,
    #[doc = "< total endpoint dram occupancy in bytes by model output tensors"]
    pub model_total_output_tensor_occupancy_size: u32,
    #[doc = "< \\since r5.3 void* handle which can be compared to `handle` member of dv_model_t"]
    pub model_handle: *mut dv_model_handle_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_model_statistics"][::std::mem::size_of::<dv_model_statistics>() - 40usize];
    ["Alignment of dv_model_statistics"][::std::mem::align_of::<dv_model_statistics>() - 8usize];
    ["Offset of field: dv_model_statistics::model"]
        [::std::mem::offset_of!(dv_model_statistics, model) - 0usize];
    ["Offset of field: dv_model_statistics::active_input_tensors_count"]
        [::std::mem::offset_of!(dv_model_statistics, active_input_tensors_count) - 4usize];
    ["Offset of field: dv_model_statistics::active_output_tensors_count"]
        [::std::mem::offset_of!(dv_model_statistics, active_output_tensors_count) - 8usize];
    ["Offset of field: dv_model_statistics::active_inferences_count"]
        [::std::mem::offset_of!(dv_model_statistics, active_inferences_count) - 12usize];
    ["Offset of field: dv_model_statistics::model_total_dram_occupancy_size"]
        [::std::mem::offset_of!(dv_model_statistics, model_total_dram_occupancy_size) - 16usize];
    ["Offset of field: dv_model_statistics::model_total_input_tensor_occupancy_size"][::std::mem::offset_of!(
        dv_model_statistics,
        model_total_input_tensor_occupancy_size
    ) - 20usize];
    ["Offset of field: dv_model_statistics::model_total_output_tensor_occupancy_size"][::std::mem::offset_of!(
        dv_model_statistics,
        model_total_output_tensor_occupancy_size
    ) - 24usize];
    ["Offset of field: dv_model_statistics::model_handle"]
        [::std::mem::offset_of!(dv_model_statistics, model_handle) - 32usize];
};
pub type dv_model_statistics_t = dv_model_statistics;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_endpoint_stats {
    #[doc = "< endpoint handle"]
    pub ep: *mut dv_endpoint_t,
    #[doc = "< endpoint state"]
    pub state: dv_endpoint_state_t,
    #[doc = "< endpoint system core clock in MHz"]
    pub ep_sys_clk: ::std::os::raw::c_int,
    #[doc = "< endpoint dram clock in MHz"]
    pub ep_dram_clk: ::std::os::raw::c_int,
    #[doc = "< average of endpoint core voltage across all measurement point in hardware in volts"]
    pub ep_core_voltage: f32,
    #[doc = "< average of endpoint temperature across all measurement point in hardware in degree celsius"]
    pub ep_temp: f32,
    #[doc = "< number of inference queues available for the endpoint [unsupported]"]
    pub num_inference_queues: ::std::os::raw::c_int,
    #[doc = "< inference queue statistics for the endpoint [unsupported]"]
    pub ep_infq_stats: *mut dv_inference_queue_statistics_t,
    #[doc = "< number of active models present in endpoint [unsupported]"]
    pub num_active_models: ::std::os::raw::c_int,
    #[doc = "< statistics for all models active on the endpoint [unsupported]"]
    pub model_stats: *mut dv_model_statistics_t,
    #[doc = "< endpoint dram statistics"]
    pub ep_dram_stats: dv_endpoint_dram_statistics_t,
    #[doc = "< endpoint power state [unsupported]"]
    pub ep_power_state: dv_endpoint_power_state_t,
    #[doc = "< endpoint soft reset count, non zero for usb devices"]
    pub ep_soft_reset_count: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_endpoint_stats"][::std::mem::size_of::<dv_endpoint_stats>() - 120usize];
    ["Alignment of dv_endpoint_stats"][::std::mem::align_of::<dv_endpoint_stats>() - 8usize];
    ["Offset of field: dv_endpoint_stats::ep"]
        [::std::mem::offset_of!(dv_endpoint_stats, ep) - 0usize];
    ["Offset of field: dv_endpoint_stats::state"]
        [::std::mem::offset_of!(dv_endpoint_stats, state) - 8usize];
    ["Offset of field: dv_endpoint_stats::ep_sys_clk"]
        [::std::mem::offset_of!(dv_endpoint_stats, ep_sys_clk) - 12usize];
    ["Offset of field: dv_endpoint_stats::ep_dram_clk"]
        [::std::mem::offset_of!(dv_endpoint_stats, ep_dram_clk) - 16usize];
    ["Offset of field: dv_endpoint_stats::ep_core_voltage"]
        [::std::mem::offset_of!(dv_endpoint_stats, ep_core_voltage) - 20usize];
    ["Offset of field: dv_endpoint_stats::ep_temp"]
        [::std::mem::offset_of!(dv_endpoint_stats, ep_temp) - 24usize];
    ["Offset of field: dv_endpoint_stats::num_inference_queues"]
        [::std::mem::offset_of!(dv_endpoint_stats, num_inference_queues) - 28usize];
    ["Offset of field: dv_endpoint_stats::ep_infq_stats"]
        [::std::mem::offset_of!(dv_endpoint_stats, ep_infq_stats) - 32usize];
    ["Offset of field: dv_endpoint_stats::num_active_models"]
        [::std::mem::offset_of!(dv_endpoint_stats, num_active_models) - 40usize];
    ["Offset of field: dv_endpoint_stats::model_stats"]
        [::std::mem::offset_of!(dv_endpoint_stats, model_stats) - 48usize];
    ["Offset of field: dv_endpoint_stats::ep_dram_stats"]
        [::std::mem::offset_of!(dv_endpoint_stats, ep_dram_stats) - 56usize];
    ["Offset of field: dv_endpoint_stats::ep_power_state"]
        [::std::mem::offset_of!(dv_endpoint_stats, ep_power_state) - 112usize];
    ["Offset of field: dv_endpoint_stats::ep_soft_reset_count"]
        [::std::mem::offset_of!(dv_endpoint_stats, ep_soft_reset_count) - 116usize];
};
pub type dv_endpoint_statistics_t = dv_endpoint_stats;
#[doc = " Usage:\n for quantization and dequantization of inputs/outputs is different for different qmodes\n for qmode - 0, 1, 2 and 3:\n    quantized_value = round(float_value * qn)\n    dequantized_value = quantized_value / qn\n for qmode - 9:\n    quantized_value = round(float_value / qn) + offset\n    dequantized_value = (float_value - offset )* qn"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_model_input_preprocess_param {
    #[doc = "< quantization scale"]
    pub qn: f32,
    #[doc = "< per channel scale for nch<=3, else null"]
    pub scale: *mut f32,
    #[doc = "< per channel mean for nch<=3, else null"]
    pub mean: *mut f32,
    #[doc = "< aspect ratio based resize"]
    pub aspect_resize: bool,
    #[doc = "< mirror effect"]
    pub mirror: bool,
    #[doc = "< center crop"]
    pub center_crop: bool,
    #[doc = "< convert BGR to RGB"]
    pub bgr_to_rgb: bool,
    #[doc = "< interpolation method supported by OpenCV"]
    pub interpolation: ::std::os::raw::c_int,
    #[doc = "< input range ((-128) - (128)) / (0 - 255)"]
    pub is_signed: bool,
    #[doc = "< bytes per pixel"]
    pub bpp: ::std::os::raw::c_int,
    #[doc = "< output scale"]
    pub output_scale: f32,
    #[doc = "< aspect resize scaling factor"]
    pub aspect_resize_scale: f32,
    #[doc = "< offset for asymmetric quantization"]
    pub offset: ::std::os::raw::c_int,
    #[doc = "< quantization mode"]
    pub qmode: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_model_input_preprocess_param"]
        [::std::mem::size_of::<dv_model_input_preprocess_param>() - 56usize];
    ["Alignment of dv_model_input_preprocess_param"]
        [::std::mem::align_of::<dv_model_input_preprocess_param>() - 8usize];
    ["Offset of field: dv_model_input_preprocess_param::qn"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, qn) - 0usize];
    ["Offset of field: dv_model_input_preprocess_param::scale"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, scale) - 8usize];
    ["Offset of field: dv_model_input_preprocess_param::mean"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, mean) - 16usize];
    ["Offset of field: dv_model_input_preprocess_param::aspect_resize"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, aspect_resize) - 24usize];
    ["Offset of field: dv_model_input_preprocess_param::mirror"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, mirror) - 25usize];
    ["Offset of field: dv_model_input_preprocess_param::center_crop"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, center_crop) - 26usize];
    ["Offset of field: dv_model_input_preprocess_param::bgr_to_rgb"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, bgr_to_rgb) - 27usize];
    ["Offset of field: dv_model_input_preprocess_param::interpolation"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, interpolation) - 28usize];
    ["Offset of field: dv_model_input_preprocess_param::is_signed"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, is_signed) - 32usize];
    ["Offset of field: dv_model_input_preprocess_param::bpp"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, bpp) - 36usize];
    ["Offset of field: dv_model_input_preprocess_param::output_scale"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, output_scale) - 40usize];
    ["Offset of field: dv_model_input_preprocess_param::aspect_resize_scale"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, aspect_resize_scale) - 44usize];
    ["Offset of field: dv_model_input_preprocess_param::offset"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, offset) - 48usize];
    ["Offset of field: dv_model_input_preprocess_param::qmode"]
        [::std::mem::offset_of!(dv_model_input_preprocess_param, qmode) - 52usize];
};
#[doc = " Usage:\n for quantization and dequantization of inputs/outputs is different for different qmodes\n for qmode - 0, 1, 2 and 3:\n    quantized_value = round(float_value * qn)\n    dequantized_value = quantized_value / qn\n for qmode - 9:\n    quantized_value = round(float_value / qn) + offset\n    dequantized_value = (float_value - offset )* qn"]
pub type dv_model_input_preprocess_param_t = dv_model_input_preprocess_param;
#[doc = " Model Input Tensor Parameters"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_model_input_param {
    pub preprocess_param: *mut dv_model_input_preprocess_param_t,
    #[doc = "< input layer id"]
    pub layer_id: ::std::os::raw::c_int,
    #[doc = "< input blob id within the layer"]
    pub blob_id: ::std::os::raw::c_int,
    #[doc = "< input layer name"]
    pub layer_name: *mut ::std::os::raw::c_char,
    #[doc = "< input blob name within the layer"]
    pub blob_name: *mut ::std::os::raw::c_char,
    #[doc = "< input layer type"]
    pub layer_type: *mut ::std::os::raw::c_char,
    #[doc = "< input layout"]
    pub layout: *mut ::std::os::raw::c_char,
    #[doc = "< tensor size in bytes"]
    pub size: ::std::os::raw::c_int,
    #[doc = "< tensor width"]
    pub width: ::std::os::raw::c_int,
    #[doc = "< tensor height"]
    pub height: ::std::os::raw::c_int,
    #[doc = "< depth dimension"]
    pub depth: ::std::os::raw::c_int,
    #[doc = "< number of channels"]
    pub nch: ::std::os::raw::c_int,
    #[doc = "< bytes per pixel"]
    pub bpp: ::std::os::raw::c_int,
    #[doc = "< batch size"]
    pub batch_size: ::std::os::raw::c_int,
    #[doc = "< num"]
    pub num: ::std::os::raw::c_int,
    #[doc = "<source graph input layer name"]
    pub src_graph_layer_name: *mut ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_model_input_param"][::std::mem::size_of::<dv_model_input_param>() - 88usize];
    ["Alignment of dv_model_input_param"][::std::mem::align_of::<dv_model_input_param>() - 8usize];
    ["Offset of field: dv_model_input_param::preprocess_param"]
        [::std::mem::offset_of!(dv_model_input_param, preprocess_param) - 0usize];
    ["Offset of field: dv_model_input_param::layer_id"]
        [::std::mem::offset_of!(dv_model_input_param, layer_id) - 8usize];
    ["Offset of field: dv_model_input_param::blob_id"]
        [::std::mem::offset_of!(dv_model_input_param, blob_id) - 12usize];
    ["Offset of field: dv_model_input_param::layer_name"]
        [::std::mem::offset_of!(dv_model_input_param, layer_name) - 16usize];
    ["Offset of field: dv_model_input_param::blob_name"]
        [::std::mem::offset_of!(dv_model_input_param, blob_name) - 24usize];
    ["Offset of field: dv_model_input_param::layer_type"]
        [::std::mem::offset_of!(dv_model_input_param, layer_type) - 32usize];
    ["Offset of field: dv_model_input_param::layout"]
        [::std::mem::offset_of!(dv_model_input_param, layout) - 40usize];
    ["Offset of field: dv_model_input_param::size"]
        [::std::mem::offset_of!(dv_model_input_param, size) - 48usize];
    ["Offset of field: dv_model_input_param::width"]
        [::std::mem::offset_of!(dv_model_input_param, width) - 52usize];
    ["Offset of field: dv_model_input_param::height"]
        [::std::mem::offset_of!(dv_model_input_param, height) - 56usize];
    ["Offset of field: dv_model_input_param::depth"]
        [::std::mem::offset_of!(dv_model_input_param, depth) - 60usize];
    ["Offset of field: dv_model_input_param::nch"]
        [::std::mem::offset_of!(dv_model_input_param, nch) - 64usize];
    ["Offset of field: dv_model_input_param::bpp"]
        [::std::mem::offset_of!(dv_model_input_param, bpp) - 68usize];
    ["Offset of field: dv_model_input_param::batch_size"]
        [::std::mem::offset_of!(dv_model_input_param, batch_size) - 72usize];
    ["Offset of field: dv_model_input_param::num"]
        [::std::mem::offset_of!(dv_model_input_param, num) - 76usize];
    ["Offset of field: dv_model_input_param::src_graph_layer_name"]
        [::std::mem::offset_of!(dv_model_input_param, src_graph_layer_name) - 80usize];
};
#[doc = " Model Input Tensor Parameters"]
pub type dv_model_input_param_t = dv_model_input_param;
#[doc = " Model output post processing parameters"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_model_output_postprocess_param {
    #[doc = "< output quantization parameter"]
    pub qn: f32,
    #[doc = "< output is structured or not"]
    pub is_struct_format: bool,
    #[doc = "< output is float type"]
    pub is_float: bool,
    #[doc = "< output is signed or not"]
    pub is_signed: bool,
    #[doc = "< output scale for asymmetric quantization"]
    pub output_scale: f32,
    #[doc = "< offset for asymmetric quantization"]
    pub offset: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_model_output_postprocess_param"]
        [::std::mem::size_of::<dv_model_output_postprocess_param>() - 16usize];
    ["Alignment of dv_model_output_postprocess_param"]
        [::std::mem::align_of::<dv_model_output_postprocess_param>() - 4usize];
    ["Offset of field: dv_model_output_postprocess_param::qn"]
        [::std::mem::offset_of!(dv_model_output_postprocess_param, qn) - 0usize];
    ["Offset of field: dv_model_output_postprocess_param::is_struct_format"]
        [::std::mem::offset_of!(dv_model_output_postprocess_param, is_struct_format) - 4usize];
    ["Offset of field: dv_model_output_postprocess_param::is_float"]
        [::std::mem::offset_of!(dv_model_output_postprocess_param, is_float) - 5usize];
    ["Offset of field: dv_model_output_postprocess_param::is_signed"]
        [::std::mem::offset_of!(dv_model_output_postprocess_param, is_signed) - 6usize];
    ["Offset of field: dv_model_output_postprocess_param::output_scale"]
        [::std::mem::offset_of!(dv_model_output_postprocess_param, output_scale) - 8usize];
    ["Offset of field: dv_model_output_postprocess_param::offset"]
        [::std::mem::offset_of!(dv_model_output_postprocess_param, offset) - 12usize];
};
#[doc = " Model output post processing parameters"]
pub type dv_model_output_postprocess_param_t = dv_model_output_postprocess_param;
#[doc = " Model output parameters"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_model_output_param {
    #[doc = "<"]
    pub postprocess_param: *mut dv_model_output_postprocess_param_t,
    #[doc = "< layer id"]
    pub layer_id: ::std::os::raw::c_int,
    #[doc = "< input blob id within the layer"]
    pub blob_id: ::std::os::raw::c_int,
    #[doc = "< layer fused parent id"]
    pub fused_parent_id: ::std::os::raw::c_int,
    #[doc = "< layer name"]
    pub layer_name: *mut ::std::os::raw::c_char,
    #[doc = "< input blob name within the layer"]
    pub blob_name: *mut ::std::os::raw::c_char,
    #[doc = "< layer fused parent name"]
    pub layer_fused_parent_name: *mut ::std::os::raw::c_char,
    #[doc = "< layer type"]
    pub layer_type: *mut ::std::os::raw::c_char,
    #[doc = "< output layout"]
    pub layout: *mut ::std::os::raw::c_char,
    #[doc = "< layer size in bytes"]
    pub size: ::std::os::raw::c_int,
    #[doc = "< layer width in pixels"]
    pub width: ::std::os::raw::c_int,
    #[doc = "< layer height in pixels"]
    pub height: ::std::os::raw::c_int,
    #[doc = "< layer depth in pixels"]
    pub depth: ::std::os::raw::c_int,
    #[doc = "< number of channels"]
    pub nch: ::std::os::raw::c_int,
    #[doc = "< bytes per pixel"]
    pub bpp: ::std::os::raw::c_int,
    #[doc = "< number of classes for which model is trained on"]
    pub num_classes: ::std::os::raw::c_int,
    #[doc = "< output type of layer"]
    pub layer_output_type: dv_layer_output_type_t,
    #[doc = "< num dimension >"]
    pub num: ::std::os::raw::c_int,
    #[doc = "< max batch id"]
    pub max_dynamic_id: ::std::os::raw::c_int,
    #[doc = "< source graph output layer name"]
    pub src_graph_layer_name: *mut ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_model_output_param"][::std::mem::size_of::<dv_model_output_param>() - 112usize];
    ["Alignment of dv_model_output_param"]
        [::std::mem::align_of::<dv_model_output_param>() - 8usize];
    ["Offset of field: dv_model_output_param::postprocess_param"]
        [::std::mem::offset_of!(dv_model_output_param, postprocess_param) - 0usize];
    ["Offset of field: dv_model_output_param::layer_id"]
        [::std::mem::offset_of!(dv_model_output_param, layer_id) - 8usize];
    ["Offset of field: dv_model_output_param::blob_id"]
        [::std::mem::offset_of!(dv_model_output_param, blob_id) - 12usize];
    ["Offset of field: dv_model_output_param::fused_parent_id"]
        [::std::mem::offset_of!(dv_model_output_param, fused_parent_id) - 16usize];
    ["Offset of field: dv_model_output_param::layer_name"]
        [::std::mem::offset_of!(dv_model_output_param, layer_name) - 24usize];
    ["Offset of field: dv_model_output_param::blob_name"]
        [::std::mem::offset_of!(dv_model_output_param, blob_name) - 32usize];
    ["Offset of field: dv_model_output_param::layer_fused_parent_name"]
        [::std::mem::offset_of!(dv_model_output_param, layer_fused_parent_name) - 40usize];
    ["Offset of field: dv_model_output_param::layer_type"]
        [::std::mem::offset_of!(dv_model_output_param, layer_type) - 48usize];
    ["Offset of field: dv_model_output_param::layout"]
        [::std::mem::offset_of!(dv_model_output_param, layout) - 56usize];
    ["Offset of field: dv_model_output_param::size"]
        [::std::mem::offset_of!(dv_model_output_param, size) - 64usize];
    ["Offset of field: dv_model_output_param::width"]
        [::std::mem::offset_of!(dv_model_output_param, width) - 68usize];
    ["Offset of field: dv_model_output_param::height"]
        [::std::mem::offset_of!(dv_model_output_param, height) - 72usize];
    ["Offset of field: dv_model_output_param::depth"]
        [::std::mem::offset_of!(dv_model_output_param, depth) - 76usize];
    ["Offset of field: dv_model_output_param::nch"]
        [::std::mem::offset_of!(dv_model_output_param, nch) - 80usize];
    ["Offset of field: dv_model_output_param::bpp"]
        [::std::mem::offset_of!(dv_model_output_param, bpp) - 84usize];
    ["Offset of field: dv_model_output_param::num_classes"]
        [::std::mem::offset_of!(dv_model_output_param, num_classes) - 88usize];
    ["Offset of field: dv_model_output_param::layer_output_type"]
        [::std::mem::offset_of!(dv_model_output_param, layer_output_type) - 92usize];
    ["Offset of field: dv_model_output_param::num"]
        [::std::mem::offset_of!(dv_model_output_param, num) - 96usize];
    ["Offset of field: dv_model_output_param::max_dynamic_id"]
        [::std::mem::offset_of!(dv_model_output_param, max_dynamic_id) - 100usize];
    ["Offset of field: dv_model_output_param::src_graph_layer_name"]
        [::std::mem::offset_of!(dv_model_output_param, src_graph_layer_name) - 104usize];
};
#[doc = " Model output parameters"]
pub type dv_model_output_param_t = dv_model_output_param;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_compiler_statistics {
    #[doc = "< DV1 config name, governed on ep system core clock"]
    pub config_name: *mut ::std::os::raw::c_char,
    #[doc = "< total cycles estimated by compiler"]
    pub cycles: f32,
    #[doc = "< inference per seconds estimated by compiler"]
    pub ips: f32,
    #[doc = "< ep dram estimated by compiler"]
    pub ddr_bandwidth: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_compiler_statistics"][::std::mem::size_of::<dv_compiler_statistics>() - 24usize];
    ["Alignment of dv_compiler_statistics"]
        [::std::mem::align_of::<dv_compiler_statistics>() - 8usize];
    ["Offset of field: dv_compiler_statistics::config_name"]
        [::std::mem::offset_of!(dv_compiler_statistics, config_name) - 0usize];
    ["Offset of field: dv_compiler_statistics::cycles"]
        [::std::mem::offset_of!(dv_compiler_statistics, cycles) - 8usize];
    ["Offset of field: dv_compiler_statistics::ips"]
        [::std::mem::offset_of!(dv_compiler_statistics, ips) - 12usize];
    ["Offset of field: dv_compiler_statistics::ddr_bandwidth"]
        [::std::mem::offset_of!(dv_compiler_statistics, ddr_bandwidth) - 16usize];
};
pub type dv_compiler_statistics_t = dv_compiler_statistics;
pub const DV_MODEL_TYPE_DV_MODEL_TYPE_ARA1_CNN: DV_MODEL_TYPE = 0;
pub const DV_MODEL_TYPE_DV_MODEL_TYPE_ARA2_CNN: DV_MODEL_TYPE = 1;
pub const DV_MODEL_TYPE_DV_MODEL_TYPE_ARA2_LLM: DV_MODEL_TYPE = 2;
pub const DV_MODEL_TYPE_DV_MODEL_TYPE_ARA2_LLM_DYN_V2: DV_MODEL_TYPE = 3;
pub type DV_MODEL_TYPE = ::std::os::raw::c_uint;
pub use self::DV_MODEL_TYPE as dv_model_type_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_model_options {
    #[doc = "< model name"]
    pub model_name: *mut ::std::os::raw::c_char,
    #[doc = "< priority of the model [unused]"]
    pub priority: dv_model_priority_level_t,
    #[doc = "< if true, the model is cached on disk"]
    pub cache: bool,
    #[doc = "< if true, the model load API immediately return \\see\ndv_model_load_wait_for_completion"]
    pub async_: bool,
    #[doc = "< specify the model type, if not specified it will be  DV_MODEL_TYPE_ARA2_CNN"]
    pub model_type: dv_model_type_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_model_options"][::std::mem::size_of::<dv_model_options>() - 24usize];
    ["Alignment of dv_model_options"][::std::mem::align_of::<dv_model_options>() - 8usize];
    ["Offset of field: dv_model_options::model_name"]
        [::std::mem::offset_of!(dv_model_options, model_name) - 0usize];
    ["Offset of field: dv_model_options::priority"]
        [::std::mem::offset_of!(dv_model_options, priority) - 8usize];
    ["Offset of field: dv_model_options::cache"]
        [::std::mem::offset_of!(dv_model_options, cache) - 12usize];
    ["Offset of field: dv_model_options::async_"]
        [::std::mem::offset_of!(dv_model_options, async_) - 13usize];
    ["Offset of field: dv_model_options::model_type"]
        [::std::mem::offset_of!(dv_model_options, model_type) - 16usize];
};
pub type dv_model_load_options_t = dv_model_options;
pub const DV_INFER_TYPE_DV_INFER_TYPE_ARA1_CNN: DV_INFER_TYPE = 0;
pub const DV_INFER_TYPE_DV_INFER_TYPE_ARA2_CNN: DV_INFER_TYPE = 1;
pub const DV_INFER_TYPE_DV_INFER_TYPE_LLM_PROMPT_PROCESSING: DV_INFER_TYPE = 2;
pub const DV_INFER_TYPE_DV_INFER_TYPE_LLM_FOLLOWUP_PROMPT_PROCESSING: DV_INFER_TYPE = 3;
pub const DV_INFER_TYPE_DV_INFER_TYPE_LLM_TOKEN_GENERATION: DV_INFER_TYPE = 4;
pub type DV_INFER_TYPE = ::std::os::raw::c_uint;
pub use self::DV_INFER_TYPE as dv_infer_type_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_infer_options {
    pub enable_stats: bool,
    #[doc = "< specify the model type, if not specified it will be  DV_MODEL_TYPE_ARA2_CNN"]
    pub infer_type: dv_infer_type_t,
    pub active_tokens: u64,
    pub valid_tokens: u32,
    pub tokens_to_skip: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_infer_options"][::std::mem::size_of::<dv_infer_options>() - 24usize];
    ["Alignment of dv_infer_options"][::std::mem::align_of::<dv_infer_options>() - 8usize];
    ["Offset of field: dv_infer_options::enable_stats"]
        [::std::mem::offset_of!(dv_infer_options, enable_stats) - 0usize];
    ["Offset of field: dv_infer_options::infer_type"]
        [::std::mem::offset_of!(dv_infer_options, infer_type) - 4usize];
    ["Offset of field: dv_infer_options::active_tokens"]
        [::std::mem::offset_of!(dv_infer_options, active_tokens) - 8usize];
    ["Offset of field: dv_infer_options::valid_tokens"]
        [::std::mem::offset_of!(dv_infer_options, valid_tokens) - 16usize];
    ["Offset of field: dv_infer_options::tokens_to_skip"]
        [::std::mem::offset_of!(dv_infer_options, tokens_to_skip) - 20usize];
};
pub type dv_infer_options_t = dv_infer_options;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_model_llm_params {
    pub vocab_size: u32,
    pub embedding_size: u32,
    pub input_precision: u32,
    pub output_precision: u32,
    pub max_num_tokens: u32,
    pub is_dynamic: u32,
    pub num_inputs: u32,
    pub pad_token_id: u32,
    pub eos_token_id: u32,
    pub bos_token_id: u32,
    pub embedding_lookup_addr: u64,
    pub embedding_lookup_scale_addr: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_model_llm_params"][::std::mem::size_of::<dv_model_llm_params>() - 56usize];
    ["Alignment of dv_model_llm_params"][::std::mem::align_of::<dv_model_llm_params>() - 8usize];
    ["Offset of field: dv_model_llm_params::vocab_size"]
        [::std::mem::offset_of!(dv_model_llm_params, vocab_size) - 0usize];
    ["Offset of field: dv_model_llm_params::embedding_size"]
        [::std::mem::offset_of!(dv_model_llm_params, embedding_size) - 4usize];
    ["Offset of field: dv_model_llm_params::input_precision"]
        [::std::mem::offset_of!(dv_model_llm_params, input_precision) - 8usize];
    ["Offset of field: dv_model_llm_params::output_precision"]
        [::std::mem::offset_of!(dv_model_llm_params, output_precision) - 12usize];
    ["Offset of field: dv_model_llm_params::max_num_tokens"]
        [::std::mem::offset_of!(dv_model_llm_params, max_num_tokens) - 16usize];
    ["Offset of field: dv_model_llm_params::is_dynamic"]
        [::std::mem::offset_of!(dv_model_llm_params, is_dynamic) - 20usize];
    ["Offset of field: dv_model_llm_params::num_inputs"]
        [::std::mem::offset_of!(dv_model_llm_params, num_inputs) - 24usize];
    ["Offset of field: dv_model_llm_params::pad_token_id"]
        [::std::mem::offset_of!(dv_model_llm_params, pad_token_id) - 28usize];
    ["Offset of field: dv_model_llm_params::eos_token_id"]
        [::std::mem::offset_of!(dv_model_llm_params, eos_token_id) - 32usize];
    ["Offset of field: dv_model_llm_params::bos_token_id"]
        [::std::mem::offset_of!(dv_model_llm_params, bos_token_id) - 36usize];
    ["Offset of field: dv_model_llm_params::embedding_lookup_addr"]
        [::std::mem::offset_of!(dv_model_llm_params, embedding_lookup_addr) - 40usize];
    ["Offset of field: dv_model_llm_params::embedding_lookup_scale_addr"]
        [::std::mem::offset_of!(dv_model_llm_params, embedding_lookup_scale_addr) - 48usize];
};
pub type dv_model_llm_params_t = dv_model_llm_params;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_llm_cfg_upd_req_t {
    pub top_k: u32,
    pub top_p: f32,
    pub temperature: f32,
    pub repetition_penalty: f32,
    pub target_token_post_mcp: u32,
    pub target_token_pre_mcp: u32,
    pub target_prompt_post_mcp: u32,
    pub target_prompt_pre_mcp: u32,
    pub draft_token_post_mcp: u32,
    pub draft_token_pre_mcp: u32,
    pub draft_prompt_post_mcp: u32,
    pub draft_prompt_pre_mcp: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_llm_cfg_upd_req_t"][::std::mem::size_of::<dv_llm_cfg_upd_req_t>() - 48usize];
    ["Alignment of dv_llm_cfg_upd_req_t"][::std::mem::align_of::<dv_llm_cfg_upd_req_t>() - 4usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::top_k"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, top_k) - 0usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::top_p"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, top_p) - 4usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::temperature"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, temperature) - 8usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::repetition_penalty"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, repetition_penalty) - 12usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::target_token_post_mcp"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, target_token_post_mcp) - 16usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::target_token_pre_mcp"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, target_token_pre_mcp) - 20usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::target_prompt_post_mcp"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, target_prompt_post_mcp) - 24usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::target_prompt_pre_mcp"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, target_prompt_pre_mcp) - 28usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::draft_token_post_mcp"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, draft_token_post_mcp) - 32usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::draft_token_pre_mcp"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, draft_token_pre_mcp) - 36usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::draft_prompt_post_mcp"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, draft_prompt_post_mcp) - 40usize];
    ["Offset of field: dv_llm_cfg_upd_req_t::draft_prompt_pre_mcp"]
        [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, draft_prompt_pre_mcp) - 44usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_model {
    #[doc = "< private handle, managed by client library"]
    pub handle: *mut dv_model_handle_t,
    #[doc = "< session handle on which model is loaded"]
    pub session: *mut dv_session_t,
    #[doc = "< endpoint handle on which model is loaded"]
    pub endpoint: *mut dv_endpoint_t,
    #[doc = "< model version as generated by compiler"]
    pub version: dv_version_t,
    #[doc = "< model name provided by user"]
    pub name: *mut ::std::os::raw::c_char,
    #[doc = "< model type"]
    pub model_type: dv_model_type_t,
    #[doc = "< internal model name as generated by compiler"]
    pub internal_name: *mut ::std::os::raw::c_char,
    #[doc = "< number of inputs needed by model"]
    pub num_inputs: ::std::os::raw::c_int,
    #[doc = "< number of output produced by model"]
    pub num_outputs: ::std::os::raw::c_int,
    #[doc = "< model priority as set by user [unused]"]
    pub priority: dv_model_priority_level_t,
    #[doc = "< list of input params"]
    pub input_param: *mut dv_model_input_param_t,
    #[doc = "< list of output params"]
    pub output_param: *mut dv_model_output_param_t,
    #[doc = "< list of llm params, valid if model is llm model"]
    pub llm_params: *mut dv_model_llm_params_t,
    #[doc = "< [unsupported]"]
    pub num_compiler_config: ::std::os::raw::c_int,
    #[doc = "< [unsupported]"]
    pub compiler_stats: *mut dv_compiler_statistics_t,
    #[doc = "< [unsupported]"]
    pub model_load_options: *mut dv_model_load_options_t,
    #[doc = "< [unsupported]"]
    pub cp_layer: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_model"][::std::mem::size_of::<dv_model>() - 128usize];
    ["Alignment of dv_model"][::std::mem::align_of::<dv_model>() - 8usize];
    ["Offset of field: dv_model::handle"][::std::mem::offset_of!(dv_model, handle) - 0usize];
    ["Offset of field: dv_model::session"][::std::mem::offset_of!(dv_model, session) - 8usize];
    ["Offset of field: dv_model::endpoint"][::std::mem::offset_of!(dv_model, endpoint) - 16usize];
    ["Offset of field: dv_model::version"][::std::mem::offset_of!(dv_model, version) - 24usize];
    ["Offset of field: dv_model::name"][::std::mem::offset_of!(dv_model, name) - 32usize];
    ["Offset of field: dv_model::model_type"]
        [::std::mem::offset_of!(dv_model, model_type) - 40usize];
    ["Offset of field: dv_model::internal_name"]
        [::std::mem::offset_of!(dv_model, internal_name) - 48usize];
    ["Offset of field: dv_model::num_inputs"]
        [::std::mem::offset_of!(dv_model, num_inputs) - 56usize];
    ["Offset of field: dv_model::num_outputs"]
        [::std::mem::offset_of!(dv_model, num_outputs) - 60usize];
    ["Offset of field: dv_model::priority"][::std::mem::offset_of!(dv_model, priority) - 64usize];
    ["Offset of field: dv_model::input_param"]
        [::std::mem::offset_of!(dv_model, input_param) - 72usize];
    ["Offset of field: dv_model::output_param"]
        [::std::mem::offset_of!(dv_model, output_param) - 80usize];
    ["Offset of field: dv_model::llm_params"]
        [::std::mem::offset_of!(dv_model, llm_params) - 88usize];
    ["Offset of field: dv_model::num_compiler_config"]
        [::std::mem::offset_of!(dv_model, num_compiler_config) - 96usize];
    ["Offset of field: dv_model::compiler_stats"]
        [::std::mem::offset_of!(dv_model, compiler_stats) - 104usize];
    ["Offset of field: dv_model::model_load_options"]
        [::std::mem::offset_of!(dv_model, model_load_options) - 112usize];
    ["Offset of field: dv_model::cp_layer"][::std::mem::offset_of!(dv_model, cp_layer) - 120usize];
};
pub type dv_model_t = dv_model;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_infer_statistics {
    #[doc = "< ep hardware system core clock in MHz"]
    pub ep_hw_sys_clk: ::std::os::raw::c_int,
    #[doc = "< ep hardware external nnp clock in MHz"]
    pub ep_hw_nnp_clk: ::std::os::raw::c_int,
    #[doc = "< ep hardware external sbp clock in MHz"]
    pub ep_hw_sbp_clk: ::std::os::raw::c_int,
    #[doc = "< ep hardware external dram clock in MHz"]
    pub ep_hw_dram_clk: ::std::os::raw::c_int,
    #[doc = "< total cycles taken to compute\ninference in hardware, including\nfloating point computation"]
    pub ep_hw_total_inference_cycles: u32,
    #[doc = "< cycles taken to compute floating point\noperation in hardware"]
    pub ep_hw_fp_cycles: u32,
    #[doc = "< time taken in microseconds to transfer\ninput(s) from host dram to ep hardware dram"]
    pub input_transfer_time: f32,
    #[doc = "< time taken in microseconds to transfer\noutput(s) from ep hardware dram to host dram"]
    pub output_transfer_time: f32,
    #[doc = "< time taken in microseconds to submit\ninference request to ep hardware\nAs of now this is not supported and assigned a default value -1"]
    pub ep_queue_submission_time: f32,
    #[doc = "< Total number of infer retries occured  per session of proxy"]
    pub cumulative_replay_count: u32,
    #[doc = "< Total number of infer retries occured  per inference"]
    pub current_replay_count: u32,
    #[doc = "< time stamp when input\ntransfer started"]
    pub input_transfer_start_time_stamp: timespec,
    #[doc = "< time stamp when output\ntransfer started"]
    pub output_transfer_start_time_stamp: timespec,
    #[doc = "< time stamp when inference\nwent into NNP queue"]
    pub inference_start_time_stamp: timespec,
    #[doc = "< time taken for inference execution in\nmicroseconds"]
    pub inference_execution_time: f32,
    #[doc = "< input ddr address"]
    pub input_ddr_address: u32,
    #[doc = "< output ddr address"]
    pub output_ddr_address: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_infer_statistics"][::std::mem::size_of::<dv_infer_statistics>() - 112usize];
    ["Alignment of dv_infer_statistics"][::std::mem::align_of::<dv_infer_statistics>() - 8usize];
    ["Offset of field: dv_infer_statistics::ep_hw_sys_clk"]
        [::std::mem::offset_of!(dv_infer_statistics, ep_hw_sys_clk) - 0usize];
    ["Offset of field: dv_infer_statistics::ep_hw_nnp_clk"]
        [::std::mem::offset_of!(dv_infer_statistics, ep_hw_nnp_clk) - 4usize];
    ["Offset of field: dv_infer_statistics::ep_hw_sbp_clk"]
        [::std::mem::offset_of!(dv_infer_statistics, ep_hw_sbp_clk) - 8usize];
    ["Offset of field: dv_infer_statistics::ep_hw_dram_clk"]
        [::std::mem::offset_of!(dv_infer_statistics, ep_hw_dram_clk) - 12usize];
    ["Offset of field: dv_infer_statistics::ep_hw_total_inference_cycles"]
        [::std::mem::offset_of!(dv_infer_statistics, ep_hw_total_inference_cycles) - 16usize];
    ["Offset of field: dv_infer_statistics::ep_hw_fp_cycles"]
        [::std::mem::offset_of!(dv_infer_statistics, ep_hw_fp_cycles) - 20usize];
    ["Offset of field: dv_infer_statistics::input_transfer_time"]
        [::std::mem::offset_of!(dv_infer_statistics, input_transfer_time) - 24usize];
    ["Offset of field: dv_infer_statistics::output_transfer_time"]
        [::std::mem::offset_of!(dv_infer_statistics, output_transfer_time) - 28usize];
    ["Offset of field: dv_infer_statistics::ep_queue_submission_time"]
        [::std::mem::offset_of!(dv_infer_statistics, ep_queue_submission_time) - 32usize];
    ["Offset of field: dv_infer_statistics::cumulative_replay_count"]
        [::std::mem::offset_of!(dv_infer_statistics, cumulative_replay_count) - 36usize];
    ["Offset of field: dv_infer_statistics::current_replay_count"]
        [::std::mem::offset_of!(dv_infer_statistics, current_replay_count) - 40usize];
    ["Offset of field: dv_infer_statistics::input_transfer_start_time_stamp"]
        [::std::mem::offset_of!(dv_infer_statistics, input_transfer_start_time_stamp) - 48usize];
    ["Offset of field: dv_infer_statistics::output_transfer_start_time_stamp"]
        [::std::mem::offset_of!(dv_infer_statistics, output_transfer_start_time_stamp) - 64usize];
    ["Offset of field: dv_infer_statistics::inference_start_time_stamp"]
        [::std::mem::offset_of!(dv_infer_statistics, inference_start_time_stamp) - 80usize];
    ["Offset of field: dv_infer_statistics::inference_execution_time"]
        [::std::mem::offset_of!(dv_infer_statistics, inference_execution_time) - 96usize];
    ["Offset of field: dv_infer_statistics::input_ddr_address"]
        [::std::mem::offset_of!(dv_infer_statistics, input_ddr_address) - 100usize];
    ["Offset of field: dv_infer_statistics::output_ddr_address"]
        [::std::mem::offset_of!(dv_infer_statistics, output_ddr_address) - 104usize];
};
pub type dv_infer_statistics_t = dv_infer_statistics;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_infer_llm_info {
    pub llm_infer_resp_num_valid_tokens: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_infer_llm_info"][::std::mem::size_of::<dv_infer_llm_info>() - 4usize];
    ["Alignment of dv_infer_llm_info"][::std::mem::align_of::<dv_infer_llm_info>() - 4usize];
    ["Offset of field: dv_infer_llm_info::llm_infer_resp_num_valid_tokens"]
        [::std::mem::offset_of!(dv_infer_llm_info, llm_infer_resp_num_valid_tokens) - 0usize];
};
pub type dv_infer_llm_info_t = dv_infer_llm_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dv_infer_request {
    #[doc = "< private handle, managed by client library"]
    pub handle: *mut dv_infer_request_handle_t,
    #[doc = "< session for which inference is submitted"]
    pub session: *mut dv_session_t,
    #[doc = "< endpoint for which inference is queued."]
    pub ep_queued: *mut dv_endpoint_t,
    #[doc = "< when inference request is queued on group of\nendpoints, this provide endpoint info on which\ninference is submitted."]
    pub ep_submitted: *mut dv_endpoint_t,
    #[doc = "< model handle for inference request"]
    pub model: *mut dv_model_t,
    #[doc = "< input blob list"]
    pub ip_blob_list: *mut dv_blob_t,
    #[doc = "< output blob list"]
    pub op_blob_list: *mut dv_blob_t,
    #[doc = "< inference run status"]
    pub status: dv_inference_status_t,
    #[doc = "< inference stats"]
    pub stats: *mut dv_infer_statistics_t,
    pub llm_infer_info: *mut dv_infer_llm_info_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dv_infer_request"][::std::mem::size_of::<dv_infer_request>() - 80usize];
    ["Alignment of dv_infer_request"][::std::mem::align_of::<dv_infer_request>() - 8usize];
    ["Offset of field: dv_infer_request::handle"]
        [::std::mem::offset_of!(dv_infer_request, handle) - 0usize];
    ["Offset of field: dv_infer_request::session"]
        [::std::mem::offset_of!(dv_infer_request, session) - 8usize];
    ["Offset of field: dv_infer_request::ep_queued"]
        [::std::mem::offset_of!(dv_infer_request, ep_queued) - 16usize];
    ["Offset of field: dv_infer_request::ep_submitted"]
        [::std::mem::offset_of!(dv_infer_request, ep_submitted) - 24usize];
    ["Offset of field: dv_infer_request::model"]
        [::std::mem::offset_of!(dv_infer_request, model) - 32usize];
    ["Offset of field: dv_infer_request::ip_blob_list"]
        [::std::mem::offset_of!(dv_infer_request, ip_blob_list) - 40usize];
    ["Offset of field: dv_infer_request::op_blob_list"]
        [::std::mem::offset_of!(dv_infer_request, op_blob_list) - 48usize];
    ["Offset of field: dv_infer_request::status"]
        [::std::mem::offset_of!(dv_infer_request, status) - 56usize];
    ["Offset of field: dv_infer_request::stats"]
        [::std::mem::offset_of!(dv_infer_request, stats) - 64usize];
    ["Offset of field: dv_infer_request::llm_infer_info"]
        [::std::mem::offset_of!(dv_infer_request, llm_infer_info) - 72usize];
};
pub type dv_infer_request_t = dv_infer_request;
pub struct araclient {
    __library: ::libloading::Library,
    pub dv_stringify_status_code: Result<
        unsafe extern "C" fn(status_code: dv_status_code_t) -> *const ::std::os::raw::c_char,
        ::libloading::Error,
    >,
    pub dv_session_create_via_unix_socket: Result<
        unsafe extern "C" fn(
            socket_file_path: *const ::std::os::raw::c_char,
            session: *mut *mut dv_session_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_session_create_via_named_pipe: Result<
        unsafe extern "C" fn(
            named_pipe: *const ::std::os::raw::c_char,
            session: *mut *mut dv_session_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_session_create_via_tcp_ipv4_socket: Result<
        unsafe extern "C" fn(
            tcp_ip_addr: *const ::std::os::raw::c_char,
            port: ::std::os::raw::c_int,
            session: *mut *mut dv_session_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_session_close: Result<
        unsafe extern "C" fn(session: *mut dv_session_t) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_shmfd_register: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            fd: ::std::os::raw::c_int,
            size: u32,
            offset: u32,
            fd_type: ::std::os::raw::c_int,
            shm_desc: *mut *mut dv_shm_descriptor_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_shmfd_unregister: Result<
        unsafe extern "C" fn(shm_desc: *mut dv_shm_descriptor_t) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_endpoint_get_list: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            ep_list: *mut *mut dv_endpoint_t,
            ep_count: *mut ::std::os::raw::c_int,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_endpoint_get_default_group: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            grp: dv_endpoint_default_group_t,
            ep_grp: *mut *mut dv_endpoint_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_endpoint_create_group: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            ep_list: *mut *mut dv_endpoint_t,
            ep_count: ::std::os::raw::c_int,
            ep_grp: *mut *mut dv_endpoint_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_endpoint_free_group: Result<
        unsafe extern "C" fn(ep_grp: *mut dv_endpoint_t) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_endpoint_check_status: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            ep: *mut dv_endpoint_t,
            state: *mut dv_endpoint_state_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_endpoint_get_dram_statistics: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            ep: *mut dv_endpoint_t,
            ep_dram_stats: *mut *mut dv_endpoint_dram_statistics_t,
            ep_count: *mut ::std::os::raw::c_int,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_endpoint_free_dram_statistics: Result<
        unsafe extern "C" fn(
            ep_dram_stats: *mut dv_endpoint_dram_statistics_t,
            count: ::std::os::raw::c_int,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_endpoint_get_statistics: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            ep: *mut dv_endpoint_t,
            ep_stats: *mut *mut dv_endpoint_statistics_t,
            ep_count: *mut ::std::os::raw::c_int,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_endpoint_free_statistics: Result<
        unsafe extern "C" fn(
            ep_stats: *mut dv_endpoint_statistics_t,
            count: ::std::os::raw::c_int,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_model_load_from_file: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            endpt: *mut dv_endpoint_t,
            model_file_path: *const ::std::os::raw::c_char,
            model_name: *const ::std::os::raw::c_char,
            priority: dv_model_priority_level_t,
            model_handle: *mut *mut dv_model_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_model_load_from_blob: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            endpt: *mut dv_endpoint_t,
            model_blob: *mut dv_blob_t,
            model_name: *const ::std::os::raw::c_char,
            priority: dv_model_priority_level_t,
            model_handle: *mut *mut dv_model_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_model_unload: Result<
        unsafe extern "C" fn(model: *mut dv_model_t) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_model_get_parameters_from_file: Result<
        unsafe extern "C" fn(
            model_file_path: *const ::std::os::raw::c_char,
            model: *mut *mut dv_model_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_model_get_parameters_from_blob: Result<
        unsafe extern "C" fn(
            model_blob: *mut dv_blob_t,
            model: *mut *mut dv_model_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_model_free_parameters: Result<
        unsafe extern "C" fn(model: *mut dv_model_t) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_model_set_llm_cfg_params: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            ep: *mut dv_endpoint_t,
            model: *mut dv_model_t,
            llm_cfg_update: *mut dv_llm_cfg_upd_req_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_infer_sync: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            endpt: *mut dv_endpoint_t,
            model: *mut dv_model_t,
            ip_array: *mut dv_blob_t,
            op_array: *mut dv_blob_t,
            timeout: ::std::os::raw::c_int,
            enable_stats: bool,
            inf_obj: *mut *mut dv_infer_request_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_infer_async: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            endpt: *mut dv_endpoint_t,
            model: *mut dv_model_t,
            ip_array: *mut dv_blob_t,
            op_array: *mut dv_blob_t,
            enable_stats: bool,
            inf_obj: *mut *mut dv_infer_request_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_infer_wait_for_all_completion: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            inf_obj_list: *mut *mut dv_infer_request_t,
            inf_obj_count: ::std::os::raw::c_int,
            timeout: ::std::os::raw::c_int,
            completed_inf_list: *mut *mut dv_infer_request_t,
            completed_inf_count: *mut ::std::os::raw::c_int,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_infer_wait_for_completion: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            inf_obj_list: *mut *mut dv_infer_request_t,
            inf_obj_count: ::std::os::raw::c_int,
            timeout: ::std::os::raw::c_int,
            inf_obj: *mut *mut dv_infer_request_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_infer_get_req_id: Result<
        unsafe extern "C" fn(
            inf_obj: *mut dv_infer_request_t,
            req_id: *mut u64,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_infer_free: Result<
        unsafe extern "C" fn(inf_obj: *mut dv_infer_request_t) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_infer_get_inflight_count: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            count: *mut ::std::os::raw::c_int,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_get_endpoint_busyness: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            ep: *mut dv_endpoint_t,
            is_busy: *mut bool,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_infer_sync_with_options: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            endpt: *mut dv_endpoint_t,
            model: *mut dv_model_t,
            ip_array: *mut dv_blob_t,
            op_array: *mut dv_blob_t,
            timeout: ::std::os::raw::c_int,
            inf_obj: *mut *mut dv_infer_request_t,
            infer_options: *mut dv_infer_options_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_infer_async_with_options: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            endpt: *mut dv_endpoint_t,
            model: *mut dv_model_t,
            ip_array: *mut dv_blob_t,
            op_array: *mut dv_blob_t,
            inf_obj: *mut *mut dv_infer_request_t,
            infer_options: *mut dv_infer_options_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_fetch_outputs_by_layer_name: Result<
        unsafe extern "C" fn(
            inf_obj: *mut dv_infer_request_t,
            src_op_layer_name: *mut ::std::os::raw::c_char,
            op_blobs: *mut *mut dv_blob_t,
            num_op_blobs: *mut ::std::os::raw::c_int,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_model_load_from_file_with_options: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            endpt: *mut dv_endpoint_t,
            model_file_path: *const ::std::os::raw::c_char,
            model_handle: *mut *mut dv_model_t,
            options: *mut dv_model_load_options_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_model_load_from_blob_with_options: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            endpt: *mut dv_endpoint_t,
            blob: *mut dv_blob_t,
            model_handle: *mut *mut dv_model_t,
            options: *mut dv_model_load_options_t,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_exchange_current_version_details: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            product_version: *mut *mut dv_product_version_t,
            product_count: *mut u8,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_retrieve_version_details: Result<
        unsafe extern "C" fn(
            session: *mut dv_session_t,
            product_version: *mut *mut dv_product_version_t,
            product_count: *mut u8,
        ) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_get_client_lib_version: Result<
        unsafe extern "C" fn(client_lib_version: *mut dv_version_t) -> dv_status_code_t,
        ::libloading::Error,
    >,
    pub dv_free_version_details: Result<
        unsafe extern "C" fn(product_version: *mut dv_product_version_t) -> dv_status_code_t,
        ::libloading::Error,
    >,
}
impl araclient {
    pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
    where
        P: AsRef<::std::ffi::OsStr>,
    {
        let library = ::libloading::Library::new(path.as_ref())?;
        Self::from_library(library)
    }

    pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
    where
        L: Into<::libloading::Library>,
    {
        let __library = library.into();
        let dv_stringify_status_code = __library.get(b"dv_stringify_status_code\0").map(|sym| *sym);
        let dv_session_create_via_unix_socket = __library
            .get(b"dv_session_create_via_unix_socket\0")
            .map(|sym| *sym);
        let dv_session_create_via_named_pipe = __library
            .get(b"dv_session_create_via_named_pipe\0")
            .map(|sym| *sym);
        let dv_session_create_via_tcp_ipv4_socket = __library
            .get(b"dv_session_create_via_tcp_ipv4_socket\0")
            .map(|sym| *sym);
        let dv_session_close = __library.get(b"dv_session_close\0").map(|sym| *sym);
        let dv_shmfd_register = __library.get(b"dv_shmfd_register\0").map(|sym| *sym);
        let dv_shmfd_unregister = __library.get(b"dv_shmfd_unregister\0").map(|sym| *sym);
        let dv_endpoint_get_list = __library.get(b"dv_endpoint_get_list\0").map(|sym| *sym);
        let dv_endpoint_get_default_group = __library
            .get(b"dv_endpoint_get_default_group\0")
            .map(|sym| *sym);
        let dv_endpoint_create_group = __library.get(b"dv_endpoint_create_group\0").map(|sym| *sym);
        let dv_endpoint_free_group = __library.get(b"dv_endpoint_free_group\0").map(|sym| *sym);
        let dv_endpoint_check_status = __library.get(b"dv_endpoint_check_status\0").map(|sym| *sym);
        let dv_endpoint_get_dram_statistics = __library
            .get(b"dv_endpoint_get_dram_statistics\0")
            .map(|sym| *sym);
        let dv_endpoint_free_dram_statistics = __library
            .get(b"dv_endpoint_free_dram_statistics\0")
            .map(|sym| *sym);
        let dv_endpoint_get_statistics = __library
            .get(b"dv_endpoint_get_statistics\0")
            .map(|sym| *sym);
        let dv_endpoint_free_statistics = __library
            .get(b"dv_endpoint_free_statistics\0")
            .map(|sym| *sym);
        let dv_model_load_from_file = __library.get(b"dv_model_load_from_file\0").map(|sym| *sym);
        let dv_model_load_from_blob = __library.get(b"dv_model_load_from_blob\0").map(|sym| *sym);
        let dv_model_unload = __library.get(b"dv_model_unload\0").map(|sym| *sym);
        let dv_model_get_parameters_from_file = __library
            .get(b"dv_model_get_parameters_from_file\0")
            .map(|sym| *sym);
        let dv_model_get_parameters_from_blob = __library
            .get(b"dv_model_get_parameters_from_blob\0")
            .map(|sym| *sym);
        let dv_model_free_parameters = __library.get(b"dv_model_free_parameters\0").map(|sym| *sym);
        let dv_model_set_llm_cfg_params = __library
            .get(b"dv_model_set_llm_cfg_params\0")
            .map(|sym| *sym);
        let dv_infer_sync = __library.get(b"dv_infer_sync\0").map(|sym| *sym);
        let dv_infer_async = __library.get(b"dv_infer_async\0").map(|sym| *sym);
        let dv_infer_wait_for_all_completion = __library
            .get(b"dv_infer_wait_for_all_completion\0")
            .map(|sym| *sym);
        let dv_infer_wait_for_completion = __library
            .get(b"dv_infer_wait_for_completion\0")
            .map(|sym| *sym);
        let dv_infer_get_req_id = __library.get(b"dv_infer_get_req_id\0").map(|sym| *sym);
        let dv_infer_free = __library.get(b"dv_infer_free\0").map(|sym| *sym);
        let dv_infer_get_inflight_count = __library
            .get(b"dv_infer_get_inflight_count\0")
            .map(|sym| *sym);
        let dv_get_endpoint_busyness = __library.get(b"dv_get_endpoint_busyness\0").map(|sym| *sym);
        let dv_infer_sync_with_options = __library
            .get(b"dv_infer_sync_with_options\0")
            .map(|sym| *sym);
        let dv_infer_async_with_options = __library
            .get(b"dv_infer_async_with_options\0")
            .map(|sym| *sym);
        let dv_fetch_outputs_by_layer_name = __library
            .get(b"dv_fetch_outputs_by_layer_name\0")
            .map(|sym| *sym);
        let dv_model_load_from_file_with_options = __library
            .get(b"dv_model_load_from_file_with_options\0")
            .map(|sym| *sym);
        let dv_model_load_from_blob_with_options = __library
            .get(b"dv_model_load_from_blob_with_options\0")
            .map(|sym| *sym);
        let dv_exchange_current_version_details = __library
            .get(b"dv_exchange_current_version_details\0")
            .map(|sym| *sym);
        let dv_retrieve_version_details = __library
            .get(b"dv_retrieve_version_details\0")
            .map(|sym| *sym);
        let dv_get_client_lib_version = __library
            .get(b"dv_get_client_lib_version\0")
            .map(|sym| *sym);
        let dv_free_version_details = __library.get(b"dv_free_version_details\0").map(|sym| *sym);
        Ok(araclient {
            __library,
            dv_stringify_status_code,
            dv_session_create_via_unix_socket,
            dv_session_create_via_named_pipe,
            dv_session_create_via_tcp_ipv4_socket,
            dv_session_close,
            dv_shmfd_register,
            dv_shmfd_unregister,
            dv_endpoint_get_list,
            dv_endpoint_get_default_group,
            dv_endpoint_create_group,
            dv_endpoint_free_group,
            dv_endpoint_check_status,
            dv_endpoint_get_dram_statistics,
            dv_endpoint_free_dram_statistics,
            dv_endpoint_get_statistics,
            dv_endpoint_free_statistics,
            dv_model_load_from_file,
            dv_model_load_from_blob,
            dv_model_unload,
            dv_model_get_parameters_from_file,
            dv_model_get_parameters_from_blob,
            dv_model_free_parameters,
            dv_model_set_llm_cfg_params,
            dv_infer_sync,
            dv_infer_async,
            dv_infer_wait_for_all_completion,
            dv_infer_wait_for_completion,
            dv_infer_get_req_id,
            dv_infer_free,
            dv_infer_get_inflight_count,
            dv_get_endpoint_busyness,
            dv_infer_sync_with_options,
            dv_infer_async_with_options,
            dv_fetch_outputs_by_layer_name,
            dv_model_load_from_file_with_options,
            dv_model_load_from_blob_with_options,
            dv_exchange_current_version_details,
            dv_retrieve_version_details,
            dv_get_client_lib_version,
            dv_free_version_details,
        })
    }

    #[doc = " Stringify status code\n \\param[in]   status_code : status code\n \\param[out]  status      : status code as string"]
    pub unsafe fn dv_stringify_status_code(
        &self,
        status_code: dv_status_code_t,
    ) -> *const ::std::os::raw::c_char {
        (self
            .dv_stringify_status_code
            .as_ref()
            .expect("Expected function, got error."))(status_code)
    }

    #[doc = " Create a session to the server using unix file socket\n Returns DV_SUCCESS on success, else error\n \\param[in]   socket_file_path : server unix socket path\n \\param[out]  session          : session handle returned by api"]
    pub unsafe fn dv_session_create_via_unix_socket(
        &self,
        socket_file_path: *const ::std::os::raw::c_char,
        session: *mut *mut dv_session_t,
    ) -> dv_status_code_t {
        (self
            .dv_session_create_via_unix_socket
            .as_ref()
            .expect("Expected function, got error."))(socket_file_path, session)
    }

    #[doc = " Create a session to the server using windows named pipe\n Returns DV_SUCCESS on success, else error\n \\param[in]   named_pipe       : server pipe\n \\param[out]  session          : session handle returned by api"]
    pub unsafe fn dv_session_create_via_named_pipe(
        &self,
        named_pipe: *const ::std::os::raw::c_char,
        session: *mut *mut dv_session_t,
    ) -> dv_status_code_t {
        (self
            .dv_session_create_via_named_pipe
            .as_ref()
            .expect("Expected function, got error."))(named_pipe, session)
    }

    #[doc = " Create a session to the server using TCP/IPv4 sockets\n Returns DV_SUCCESS on success, else error\n \\param[in]  tcp_ip_addr      : server ipv4 address\n \\param[in]  port             : server port\n \\param[out] session          : session handle returned by api"]
    pub unsafe fn dv_session_create_via_tcp_ipv4_socket(
        &self,
        tcp_ip_addr: *const ::std::os::raw::c_char,
        port: ::std::os::raw::c_int,
        session: *mut *mut dv_session_t,
    ) -> dv_status_code_t {
        (self
            .dv_session_create_via_tcp_ipv4_socket
            .as_ref()
            .expect("Expected function, got error."))(tcp_ip_addr, port, session)
    }

    #[doc = " Close the session to the server\n Returns DV_SUCCESS on success, else error\n \\param[in]  session  : session handle"]
    pub unsafe fn dv_session_close(&self, session: *mut dv_session_t) -> dv_status_code_t {
        (self
            .dv_session_close
            .as_ref()
            .expect("Expected function, got error."))(session)
    }

    #[doc = " DV SharedFD API\n ***************************************/\n/** Register a file descriptor with the server\n Returns DV_SUCCESS on success, else error\n \\param[in]  session      : session object\n \\param[in]  fd           : file fd to share\n \\param[in]  size         : size to mmap\n \\param[in]  offset       : file offset\n \\param[in]  fd_type      : fd type to provide hint to server (reserved)\n \\param[out] shm_desc     : shared memory descriptor"]
    pub unsafe fn dv_shmfd_register(
        &self,
        session: *mut dv_session_t,
        fd: ::std::os::raw::c_int,
        size: u32,
        offset: u32,
        fd_type: ::std::os::raw::c_int,
        shm_desc: *mut *mut dv_shm_descriptor_t,
    ) -> dv_status_code_t {
        (self
            .dv_shmfd_register
            .as_ref()
            .expect("Expected function, got error."))(
            session, fd, size, offset, fd_type, shm_desc
        )
    }

    #[doc = " Un-register shared file with the server\n Returns DV_SUCCESS on success, else error\n \\param[in]  shm_desc     : shared buffer descriptor"]
    pub unsafe fn dv_shmfd_unregister(
        &self,
        shm_desc: *mut dv_shm_descriptor_t,
    ) -> dv_status_code_t {
        (self
            .dv_shmfd_unregister
            .as_ref()
            .expect("Expected function, got error."))(shm_desc)
    }

    #[doc = " Get the list of endpoints connected to the server\n Endpoint list memory is allocated by the api. It also returns the endpoint\n count connected to server Returns DV_SUCCESS on success, else error\n \\param[in]   session         : session handle\n \\param[out]  ep_list         : connected endpoint list returned by server\n \\param[out]  ep_count        : number of endpoint connected to server"]
    pub unsafe fn dv_endpoint_get_list(
        &self,
        session: *mut dv_session_t,
        ep_list: *mut *mut dv_endpoint_t,
        ep_count: *mut ::std::os::raw::c_int,
    ) -> dv_status_code_t {
        (self
            .dv_endpoint_get_list
            .as_ref()
            .expect("Expected function, got error."))(session, ep_list, ep_count)
    }

    #[doc = " Get the default endpoint group supported by server.\n Type of default group supported is defined in enum DV_ENDPOINT_DEFAULT_GROUP.\n API allocates the memory for the endpoint configuration of the group.\n Application needs to free the memory using dv_endpoint_free_group() Returns\n DV_SUCCESS on success, else error \\param[in]   session      : session handle\n \\param[in]   grp          : enum as defined in enum DV_ENDPOINT_DEFAULT_GROUP\n \\param[out]  ep_grp       : endpoint group handle"]
    pub unsafe fn dv_endpoint_get_default_group(
        &self,
        session: *mut dv_session_t,
        grp: dv_endpoint_default_group_t,
        ep_grp: *mut *mut dv_endpoint_t,
    ) -> dv_status_code_t {
        (self
            .dv_endpoint_get_default_group
            .as_ref()
            .expect("Expected function, got error."))(session, grp, ep_grp)
    }

    #[doc = " Create custom endpoint group from the endpoints connected to the server\n API allocates the memory for the endpoint configuration of the group.\n Application needs to free the memory using dv_endpoint_free_group() Returns\n DV_SUCCESS on success, else error \\param[in]   session      : session handle\n \\param[in]   ep_list      : endpoint list for which custom group needs to be\n created \\param[in]   ep_count     : number of endpoint in the list\n \\param[out]  ep_grp       : endpoint group handle"]
    pub unsafe fn dv_endpoint_create_group(
        &self,
        session: *mut dv_session_t,
        ep_list: *mut *mut dv_endpoint_t,
        ep_count: ::std::os::raw::c_int,
        ep_grp: *mut *mut dv_endpoint_t,
    ) -> dv_status_code_t {
        (self
            .dv_endpoint_create_group
            .as_ref()
            .expect("Expected function, got error."))(session, ep_list, ep_count, ep_grp)
    }

    #[doc = " Free the default/custom endpoint group\n Returns DV_SUCCESS on success, else error\n \\param[in]   session      : session handle\n \\param[out]  ep_list      : connected endpoint list returned by server\n \\param[out]  ep_count     : number of endpoint connected to server"]
    pub unsafe fn dv_endpoint_free_group(&self, ep_grp: *mut dv_endpoint_t) -> dv_status_code_t {
        (self
            .dv_endpoint_free_group
            .as_ref()
            .expect("Expected function, got error."))(ep_grp)
    }

    #[doc = " Detects endpoint state\n \\param[in]   session     : session handle\n \\param[in]   ep          : endpoint handle\n \\param[out]  state       : endpoint state"]
    pub unsafe fn dv_endpoint_check_status(
        &self,
        session: *mut dv_session_t,
        ep: *mut dv_endpoint_t,
        state: *mut dv_endpoint_state_t,
    ) -> dv_status_code_t {
        (self
            .dv_endpoint_check_status
            .as_ref()
            .expect("Expected function, got error."))(session, ep, state)
    }

    #[doc = " Get the dram usage statistics for the endpoint/endpoint group\n Server provides the snapshot of the endpoint dram usage at the time of\n request. Passing NULL to endpoint handle will provide dram statistics for all\n the endpoint connected to the server Memory for the statistics is allocated\n by API and dv_endpoint_free_dram_statistics() is needed to free up the memory\n Returns DV_SUCCESS on success, else error\n \\param[in]   session         : session handle\n \\param[in]   ep              : endpoint/endpoint group handle for particular\n endpoint or endpoint group or NULL for all endpoints \\param[out]\n ep_dram_stats   : list of endpoint dram statistics \\param[out]  ep_count :\n number of endpoint for which dram statistics is provided"]
    pub unsafe fn dv_endpoint_get_dram_statistics(
        &self,
        session: *mut dv_session_t,
        ep: *mut dv_endpoint_t,
        ep_dram_stats: *mut *mut dv_endpoint_dram_statistics_t,
        ep_count: *mut ::std::os::raw::c_int,
    ) -> dv_status_code_t {
        (self
            .dv_endpoint_get_dram_statistics
            .as_ref()
            .expect("Expected function, got error."))(session, ep, ep_dram_stats, ep_count)
    }

    #[doc = " Free the endpoint dram stats memory allocated in\n dv_endpoint_get_dram_statistics() Returns DV_SUCCESS on success, else error\n \\param[in] ep_dram_stats : endpoint dram statistics to free\n \\param[in] count         : number of items to free"]
    pub unsafe fn dv_endpoint_free_dram_statistics(
        &self,
        ep_dram_stats: *mut dv_endpoint_dram_statistics_t,
        count: ::std::os::raw::c_int,
    ) -> dv_status_code_t {
        (self
            .dv_endpoint_free_dram_statistics
            .as_ref()
            .expect("Expected function, got error."))(ep_dram_stats, count)
    }

    #[doc = " Get all the statistics for the endpoint/endpoint group\n Server provides the snapshot of the endpoint statistics at the time of\n request. Passing NULL to endpoint handle will provide statistics for all the\n endpoint connected to the server Memory for the statistics is allocated by\n API and dv_endpoint_free_statistics() is needed to free up the memory Returns\n DV_SUCCESS on success, else error\n\n Notes on usage\n -------------\n `dv_model_statistics_t` member of `dv_endpoint_statistics_t` contains 2\n fields - uint32_t model and void* model_handle. This API will return stats of\n all models loaded across all clients - the `uint32_t model` will always hold\n a value and is an server generated id. The value of the `void* model_handle`\n member can be compared to the `handle` member of `dv_model_t` to map\n `dv_model_t` objects to their corresponding `dv_model_statistics_t` objects.\n\n \\param[in]   session     : session handle\n \\param[in]   ep          : endpoint/endpoint group handle for particular\n endpoint or endpoint group or NULL for all endpoints \\param[out]  ep_stats :\n list of endpoint statistics \\param[out]  ep_count    : number of endpoint for\n which statistics is provided"]
    pub unsafe fn dv_endpoint_get_statistics(
        &self,
        session: *mut dv_session_t,
        ep: *mut dv_endpoint_t,
        ep_stats: *mut *mut dv_endpoint_statistics_t,
        ep_count: *mut ::std::os::raw::c_int,
    ) -> dv_status_code_t {
        (self
            .dv_endpoint_get_statistics
            .as_ref()
            .expect("Expected function, got error."))(session, ep, ep_stats, ep_count)
    }

    #[doc = " Free the endpoint stats memory allocated in dv_endpoint_get_statistics()\n Returns DV_SUCCESS on success, else error\n \\param[in] ep_stats  : endpoint statistics list to free\n \\param[in] count     : number of items to free"]
    pub unsafe fn dv_endpoint_free_statistics(
        &self,
        ep_stats: *mut dv_endpoint_statistics_t,
        count: ::std::os::raw::c_int,
    ) -> dv_status_code_t {
        (self
            .dv_endpoint_free_statistics
            .as_ref()
            .expect("Expected function, got error."))(ep_stats, count)
    }

    #[doc = " Creates a model object and load model contents from file and transfer it to\n endpoint Model object contains the model handle and model parameters.\n `dv_model_get_loaded_endpoint_list` returns the list of endpoints (individual\n device dv_endpoint_t handles) on which the model was successfully loaded.\n\n If model load fails on all individual devices representing `endpt`, the API\n call will error out.\n\n Returns DV_SUCCESS on success, else error\n \\param[in]   session          : session handle\n \\param[in]   endpt            : endpoint handle\n \\param[in]   model_file_path  : model file path\n \\param[in]   priority         : model priority [unused]\n \\param[in]   model_name       : model name [unused]\n \\param[out]  model_handle     : model handle returned by server"]
    pub unsafe fn dv_model_load_from_file(
        &self,
        session: *mut dv_session_t,
        endpt: *mut dv_endpoint_t,
        model_file_path: *const ::std::os::raw::c_char,
        model_name: *const ::std::os::raw::c_char,
        priority: dv_model_priority_level_t,
        model_handle: *mut *mut dv_model_t,
    ) -> dv_status_code_t {
        (self
            .dv_model_load_from_file
            .as_ref()
            .expect("Expected function, got error."))(
            session,
            endpt,
            model_file_path,
            model_name,
            priority,
            model_handle,
        )
    }

    #[doc = " Creates a model object and load model contents from blob and transfer it to\n endpoint Model object contains the model handle and model parameters.\n `dv_model_get_loaded_endpoint_list` returns the list of endpoints (individual\n device dv_endpoint_t handles) on which the model was successfully loaded.\n\n If model load fails on all individual devices representing `endpt`, the API\n call will error out.\n\n Returns DV_SUCCESS on success, else error\n \\param[in]   session          : session handle\n \\param[in]   endpt            : endpoint handle\n \\param[in]   model_blob       : model blob\n \\param[in]   priority         : model priority [unused]\n \\param[in]   model_name       : model name [unused]\n \\param[out]  model_handle     : model handle returned by server"]
    pub unsafe fn dv_model_load_from_blob(
        &self,
        session: *mut dv_session_t,
        endpt: *mut dv_endpoint_t,
        model_blob: *mut dv_blob_t,
        model_name: *const ::std::os::raw::c_char,
        priority: dv_model_priority_level_t,
        model_handle: *mut *mut dv_model_t,
    ) -> dv_status_code_t {
        (self
            .dv_model_load_from_blob
            .as_ref()
            .expect("Expected function, got error."))(
            session,
            endpt,
            model_blob,
            model_name,
            priority,
            model_handle,
        )
    }

    #[doc = " Unloads a model from the endpoint\n Returns DV_SUCCESS on success, else error\n \\param[in]  model    : model handle"]
    pub unsafe fn dv_model_unload(&self, model: *mut dv_model_t) -> dv_status_code_t {
        (self
            .dv_model_unload
            .as_ref()
            .expect("Expected function, got error."))(model)
    }

    #[doc = " Get the model parameters from model file without loading the model to\n endpoint(s) API allocates memory for the parameters. Application can free it\n by calling dv_model_free_paramaters This is a utility function, useful to get\n model parameters without loading the model to endpoint(s). The model object\n returned by the api cannot be used Returns DV_SUCCESS on success, else error\n \\param[in]  model_file_path  : model file path\n \\param[in]  model            : model parameters"]
    pub unsafe fn dv_model_get_parameters_from_file(
        &self,
        model_file_path: *const ::std::os::raw::c_char,
        model: *mut *mut dv_model_t,
    ) -> dv_status_code_t {
        (self
            .dv_model_get_parameters_from_file
            .as_ref()
            .expect("Expected function, got error."))(model_file_path, model)
    }

    #[doc = " Get the model parameters from model blob without loading the model onto\n endpoint(s) API allocates memory for the parameters. Application can free it\n by calling dv_model_free_paramaters This is a utility function, useful to get\n model parameters without loading the model to endpoint(s) Returns DV_SUCCESS\n on success, else error \\param[in]  model_blob  : model blob \\param[in]  model\n : model parameters"]
    pub unsafe fn dv_model_get_parameters_from_blob(
        &self,
        model_blob: *mut dv_blob_t,
        model: *mut *mut dv_model_t,
    ) -> dv_status_code_t {
        (self
            .dv_model_get_parameters_from_blob
            .as_ref()
            .expect("Expected function, got error."))(model_blob, model)
    }

    #[doc = " Free the memory allocations for model parameter made by\n dv_model_get_parameters_* call Returns DV_SUCCESS on success, else error\n \\param[in]  model    : model handle"]
    pub unsafe fn dv_model_free_parameters(&self, model: *mut dv_model_t) -> dv_status_code_t {
        (self
            .dv_model_free_parameters
            .as_ref()
            .expect("Expected function, got error."))(model)
    }

    #[doc = " Pass pre/post processing flags and params to proxy/mcp\n \\param[in]  session      : session handle\n \\param[in]  endpt        : endpoint handle\n \\param[in] model             : model handle // currently unused by proxy\n \\param[in] llm_cfg_update    : dv_llm_cfg_upd_req_t type representing pre/post processing flags and params"]
    pub unsafe fn dv_model_set_llm_cfg_params(
        &self,
        session: *mut dv_session_t,
        ep: *mut dv_endpoint_t,
        model: *mut dv_model_t,
        llm_cfg_update: *mut dv_llm_cfg_upd_req_t,
    ) -> dv_status_code_t {
        (self
            .dv_model_set_llm_cfg_params
            .as_ref()
            .expect("Expected function, got error."))(session, ep, model, llm_cfg_update)
    }

    #[doc = " Submit an synchronous inference for a model to an endpoint(group)\n This is a blocking call, it returns when inference is completed\n (success/error) or a timeout has occurred Input and output blobs should be\n provided as per input and output parameter provided by model Inference object\n memory will be allocated by API and can be freed upon calling dv_infer_free()\n Returns DV_SUCCESS on success, else error\n \\param[in]  session      : session handle\n \\param[in]  endpt        : endpoint handle\n \\param[in]  model        : model handle\n \\param[in]  ip_array     : an array of input blob descriptor\n \\param[in]  op_array     : an array of output blob descriptor\n \\param[in]  timeout      : maximum time in mili seconds to wait for request\n to complete \\param[in]  enable_stats : enable stats for the inference request\n (deprecated) \\param[out] inf_obj      : inference object"]
    pub unsafe fn dv_infer_sync(
        &self,
        session: *mut dv_session_t,
        endpt: *mut dv_endpoint_t,
        model: *mut dv_model_t,
        ip_array: *mut dv_blob_t,
        op_array: *mut dv_blob_t,
        timeout: ::std::os::raw::c_int,
        enable_stats: bool,
        inf_obj: *mut *mut dv_infer_request_t,
    ) -> dv_status_code_t {
        (self
            .dv_infer_sync
            .as_ref()
            .expect("Expected function, got error."))(
            session,
            endpt,
            model,
            ip_array,
            op_array,
            timeout,
            enable_stats,
            inf_obj,
        )
    }

    #[doc = " Submit an asynchronous inference for a model to an endpoint(group)\n Server returns a inference request id which can be used to get the completion\n status or wait upon for compleetion after the call. Input and output blobs\n should be provided as per input and output parameter provided by model\n Inference object memory will be allocated by API and can be freed upon\n calling dv_infer_free() Returns DV_SUCCESS on success, else error \\param[in]\n session      : session handle \\param[in]  endpt        : endpoint handle\n \\param[in]  model        : model handle\n \\param[in]  ip_array     : an array of input blob descriptor\n \\param[in]  op_array     : an array of output blob descriptor\n \\param[in]  enable_stats : enable stats for the inference request\n (deprecated) \\param[out] inf_obj      : inference object"]
    pub unsafe fn dv_infer_async(
        &self,
        session: *mut dv_session_t,
        endpt: *mut dv_endpoint_t,
        model: *mut dv_model_t,
        ip_array: *mut dv_blob_t,
        op_array: *mut dv_blob_t,
        enable_stats: bool,
        inf_obj: *mut *mut dv_infer_request_t,
    ) -> dv_status_code_t {
        (self
            .dv_infer_async
            .as_ref()
            .expect("Expected function, got error."))(
            session,
            endpt,
            model,
            ip_array,
            op_array,
            enable_stats,
            inf_obj,
        )
    }

    #[doc = " Monitor multiple inference request object and wait until, all of the\n request updates/changes run status If the list is empty it waits until,\n atleast one inference request submitted in the session changes run status and\n API keeps track of status change for a inference request and run status is\n reported only once.\n\n For non-empty request list, application needs to remove the completed\n inference object from the list. Request completion status can be reported\n multiple times.\n\n Returns DV_SUCCESS on success, else error\n \\param[in]  session      : session handle\n \\param[in]  inf_id_list  : inference request object list\n \\param[in]  inf_id_count : number of inference request to monitor\n \\param[in]  timeout      : maximum time in mili seconds to wait for inference\n request to change status; defaults to 60 seconds in case timeout is passed as\n -1"]
    pub unsafe fn dv_infer_wait_for_all_completion(
        &self,
        session: *mut dv_session_t,
        inf_obj_list: *mut *mut dv_infer_request_t,
        inf_obj_count: ::std::os::raw::c_int,
        timeout: ::std::os::raw::c_int,
        completed_inf_list: *mut *mut dv_infer_request_t,
        completed_inf_count: *mut ::std::os::raw::c_int,
    ) -> dv_status_code_t {
        (self
            .dv_infer_wait_for_all_completion
            .as_ref()
            .expect("Expected function, got error."))(
            session,
            inf_obj_list,
            inf_obj_count,
            timeout,
            completed_inf_list,
            completed_inf_count,
        )
    }

    #[doc = " Monitor multiple inference request object and wait until, atleast one of the\n request updates/changes run status If the list is empty it waits until,\n atleast one inference request submitted in the session changes run status and\n API keeps track of status change for a inference request and run status is\n reported only once.\n\n For non-empty request list, application needs to remove the completed\n inference object from the list. Request completion status can be reported\n multiple times.\n\n Returns DV_SUCCESS on success, else error\n \\param[in]  session      : session handle\n \\param[in]  inf_id_list  : inference request object list\n \\param[in]  inf_id_count : number of inference request to monitor\n \\param[in]  timeout      : maximum time in mili seconds to wait for inference\n request to change status; defaults to 60 seconds in case timeout is passed as\n -1 \\param[out] inf_obj      : inference id for which the state is changed"]
    pub unsafe fn dv_infer_wait_for_completion(
        &self,
        session: *mut dv_session_t,
        inf_obj_list: *mut *mut dv_infer_request_t,
        inf_obj_count: ::std::os::raw::c_int,
        timeout: ::std::os::raw::c_int,
        inf_obj: *mut *mut dv_infer_request_t,
    ) -> dv_status_code_t {
        (self
            .dv_infer_wait_for_completion
            .as_ref()
            .expect("Expected function, got error."))(
            session,
            inf_obj_list,
            inf_obj_count,
            timeout,
            inf_obj,
        )
    }

    #[doc = " Returns the request id of an inference that is sent by the client.\n The request id returned will be the same printed in logs if the proxy is\n passed the `-t` flag.\n\n If the inf_obj is null or if inf_obj->handle is null, DV_INVALID_HOST_PTR is\n returned. The req_id argument is not set to any value in this case.\n\n If return value is DV_SUCCESS req_id will contain the request id of the\n inference request sent to kinara inference proxy.\n\n This api is not thread safe. Calling this API on an inference handle that has\n already been `dv_infer_free`'d is incorrect and will result in undefined\n behaviour.\n\n \\param[in]  inf_obj   : inference request handle\n \\param[out] req_id    : request id of the inference request\n \\since r6.1.1"]
    pub unsafe fn dv_infer_get_req_id(
        &self,
        inf_obj: *mut dv_infer_request_t,
        req_id: *mut u64,
    ) -> dv_status_code_t {
        (self
            .dv_infer_get_req_id
            .as_ref()
            .expect("Expected function, got error."))(inf_obj, req_id)
    }

    #[doc = " Finish the life cycle for the inference request.\n API will free up the associated memory for the inference request and will no\n longer be accessible. After completion, any operation on the inference\n request will be invalid. Returns DV_SUCCESS on success, else error \\param[in]\n inf_obj      : inference object"]
    pub unsafe fn dv_infer_free(&self, inf_obj: *mut dv_infer_request_t) -> dv_status_code_t {
        (self
            .dv_infer_free
            .as_ref()
            .expect("Expected function, got error."))(inf_obj)
    }

    #[doc = " Returns the number of inflight inference requests for the session object for\n which the client library has not recieved a response from the proxy server.\n \\param[in]  session      : session handle\n \\param[out] count        : number of inference requests in flight\n \\since r5.3"]
    pub unsafe fn dv_infer_get_inflight_count(
        &self,
        session: *mut dv_session_t,
        count: *mut ::std::os::raw::c_int,
    ) -> dv_status_code_t {
        (self
            .dv_infer_get_inflight_count
            .as_ref()
            .expect("Expected function, got error."))(session, count)
    }

    #[doc = " Get the busyness for the endpoint\n Server provides busyness of any one endpoint at the time of request\n Memory for is_busy bool variable should be provided by client app\n Returns DV_SUCCESS on success, else error\n Notes on usage\n -------------\n\n \\param[in]   session     : session handle\n \\param[in]   ep          : endpoint handle for particular endpoint\n \\param[out]  is_busy    : will return true if endpoint is busy else false"]
    pub unsafe fn dv_get_endpoint_busyness(
        &self,
        session: *mut dv_session_t,
        ep: *mut dv_endpoint_t,
        is_busy: *mut bool,
    ) -> dv_status_code_t {
        (self
            .dv_get_endpoint_busyness
            .as_ref()
            .expect("Expected function, got error."))(session, ep, is_busy)
    }

    pub unsafe fn dv_infer_sync_with_options(
        &self,
        session: *mut dv_session_t,
        endpt: *mut dv_endpoint_t,
        model: *mut dv_model_t,
        ip_array: *mut dv_blob_t,
        op_array: *mut dv_blob_t,
        timeout: ::std::os::raw::c_int,
        inf_obj: *mut *mut dv_infer_request_t,
        infer_options: *mut dv_infer_options_t,
    ) -> dv_status_code_t {
        (self
            .dv_infer_sync_with_options
            .as_ref()
            .expect("Expected function, got error."))(
            session,
            endpt,
            model,
            ip_array,
            op_array,
            timeout,
            inf_obj,
            infer_options,
        )
    }

    pub unsafe fn dv_infer_async_with_options(
        &self,
        session: *mut dv_session_t,
        endpt: *mut dv_endpoint_t,
        model: *mut dv_model_t,
        ip_array: *mut dv_blob_t,
        op_array: *mut dv_blob_t,
        inf_obj: *mut *mut dv_infer_request_t,
        infer_options: *mut dv_infer_options_t,
    ) -> dv_status_code_t {
        (self
            .dv_infer_async_with_options
            .as_ref()
            .expect("Expected function, got error."))(
            session,
            endpt,
            model,
            ip_array,
            op_array,
            inf_obj,
            infer_options,
        )
    }

    #[doc = " Get output blob for given output layer names\n\n API is available from r1.2 release onwards\n Returns an array of output blobs for a given layer name\n Api should be called by passing infer handle for a successfully run inference\n Freeing infer handle will free memory pointed by output_blobs\n \\param[in] inf_obj infer request handle received after running inference successfully\n \\param[in] src_op_layer_name source graph output layer name, as specified in model output layer params struct\n \\param[out] op_blobs array of output blobs for given src_op_layer_name\n \\param[out] num_op_blobs number of output blobs in op_blobs"]
    pub unsafe fn dv_fetch_outputs_by_layer_name(
        &self,
        inf_obj: *mut dv_infer_request_t,
        src_op_layer_name: *mut ::std::os::raw::c_char,
        op_blobs: *mut *mut dv_blob_t,
        num_op_blobs: *mut ::std::os::raw::c_int,
    ) -> dv_status_code_t {
        (self
            .dv_fetch_outputs_by_layer_name
            .as_ref()
            .expect("Expected function, got error."))(
            inf_obj,
            src_op_layer_name,
            op_blobs,
            num_op_blobs,
        )
    }

    #[doc = " Creates a model object and load model contents from blob and transfer it to\n endpoint Model object contains the model handle and model parameters.\n `dv_model_get_loaded_endpoint_list` returns the list of endpoints (individual\n device dv_endpoint_t handles) on which the model was successfully loaded.\n\n If model load fails on all individual devices representing `endpt`, the API\n call will error out.\n\n Returns DV_SUCCESS on success, else error\n \\param[in]   session          : session handle\n \\param[in]   endpt            : endpoint handle\n \\param[in]   model_file_path  : path to model file\n \\param[out]  model_handle     : model handle returned by server\n \\param[in]   options          : model load options\n \\since       r6.0"]
    pub unsafe fn dv_model_load_from_file_with_options(
        &self,
        session: *mut dv_session_t,
        endpt: *mut dv_endpoint_t,
        model_file_path: *const ::std::os::raw::c_char,
        model_handle: *mut *mut dv_model_t,
        options: *mut dv_model_load_options_t,
    ) -> dv_status_code_t {
        (self
            .dv_model_load_from_file_with_options
            .as_ref()
            .expect("Expected function, got error."))(
            session,
            endpt,
            model_file_path,
            model_handle,
            options,
        )
    }

    #[doc = " Creates a model object and load model contents from blob and transfer it to\n endpoint Model object contains the model handle and model parameters.\n `dv_model_get_loaded_endpoint_list` returns the list of endpoints (individual\n device dv_endpoint_t handles) on which the model was successfully loaded.\n\n If model load fails on all individual devices representing `endpt`, the API\n call will error out.\n\n Returns DV_SUCCESS on success, else error\n \\param[in]   session          : session handle\n \\param[in]   endpt            : endpoint handle\n \\param[in]   model_blob       : dv_blob_t of the model\n \\param[in]   options          : model load options\n \\param[out]  model_handle     : model handle returned by server\n \\since       r6.0"]
    pub unsafe fn dv_model_load_from_blob_with_options(
        &self,
        session: *mut dv_session_t,
        endpt: *mut dv_endpoint_t,
        blob: *mut dv_blob_t,
        model_handle: *mut *mut dv_model_t,
        options: *mut dv_model_load_options_t,
    ) -> dv_status_code_t {
        (self
            .dv_model_load_from_blob_with_options
            .as_ref()
            .expect("Expected function, got error."))(
            session, endpt, blob, model_handle, options
        )
    }

    #[doc = " api gives current version details of\nmodel, driver, proxy, firmware version to client\n\n Returns DV_SUCCESS on success, else error\n \\param[in]    session             : session handle\n \\param[out]   product_version     : product versions\n \\param[out]   product_count       : number of product version sent"]
    pub unsafe fn dv_exchange_current_version_details(
        &self,
        session: *mut dv_session_t,
        product_version: *mut *mut dv_product_version_t,
        product_count: *mut u8,
    ) -> dv_status_code_t {
        (self
            .dv_exchange_current_version_details
            .as_ref()
            .expect("Expected function, got error."))(
            session, product_version, product_count
        )
    }

    #[doc = " api gives all supported version details of\nmodel, driver, proxy, firmware version to client\n\n Returns DV_SUCCESS on success, else error\n \\param[in]   product_version        : list of versions"]
    pub unsafe fn dv_retrieve_version_details(
        &self,
        session: *mut dv_session_t,
        product_version: *mut *mut dv_product_version_t,
        product_count: *mut u8,
    ) -> dv_status_code_t {
        (self
            .dv_retrieve_version_details
            .as_ref()
            .expect("Expected function, got error."))(
            session, product_version, product_count
        )
    }

    #[doc = " api gives current running version of client library\n\n Returns DV_SUCCESS on success, else error\n \\param[in]   client_lib_version        : fill struct with client library version"]
    pub unsafe fn dv_get_client_lib_version(
        &self,
        client_lib_version: *mut dv_version_t,
    ) -> dv_status_code_t {
        (self
            .dv_get_client_lib_version
            .as_ref()
            .expect("Expected function, got error."))(client_lib_version)
    }

    #[doc = " api deletes memory created by dv_exchange_current_version_details or dv_retrieve_version_details apis\n\n Returns DV_SUCCESS on success, else error\n \\param[in]   product_version        : list of versions"]
    pub unsafe fn dv_free_version_details(
        &self,
        product_version: *mut dv_product_version_t,
    ) -> dv_status_code_t {
        (self
            .dv_free_version_details
            .as_ref()
            .expect("Expected function, got error."))(product_version)
    }
}
