st-zrt-sys 1.26.0

//! GENERATED by `st-zrt-sys-codegen` from onnxruntime_c_api.h — DO NOT EDIT.
//! The full OrtApi function-pointer table: IDX_* indices, typed fn aliases,
//! and Api accessors, plus the opaque handle types. zrt names; no Ort*; no bindgen.
#![allow(non_camel_case_types, non_snake_case, dead_code, clippy::all)]
// Bring in the hand-written core (Api, the enums, StatusPtr, the opaque_handle! macro).
use super::*;

// ── opaque handle types (one per ORT opaque struct) ──────────────────────
opaque_handle!(AllocatorHandle);
opaque_handle!(ArenaCfgHandle);
opaque_handle!(CANNProviderOptionsHandle);
opaque_handle!(CUDAProviderOptionsHandle);
opaque_handle!(CUDAProviderOptionsV2Handle);
opaque_handle!(CompiledModelCompatibilityHandle);
opaque_handle!(CustomOpDomainHandle);
opaque_handle!(CustomOpHandle);
opaque_handle!(DataTypeHandle);
opaque_handle!(DeviceEpIncompatibilityDetailsHandle);
opaque_handle!(DnnlProviderOptionsHandle);
opaque_handle!(EnvCreationOptionsHandle);
opaque_handle!(EnvHandle);
opaque_handle!(EpAssignedNodeHandle);
opaque_handle!(EpAssignedSubgraphHandle);
opaque_handle!(EpDeviceHandle);
opaque_handle!(EpFactoryHandle);
opaque_handle!(EpGraphSupportInfoHandle);
opaque_handle!(EpHandle);
opaque_handle!(ExecutionProviderDevicePolicyHandle);
opaque_handle!(ExternalInitializerInfoHandle);
opaque_handle!(ExternalMemoryDescriptorHandle);
opaque_handle!(ExternalMemoryHandleHandle);
opaque_handle!(ExternalMemoryHandleTypeHandle);
opaque_handle!(ExternalResourceImporterHandle);
opaque_handle!(ExternalSemaphoreDescriptorHandle);
opaque_handle!(ExternalSemaphoreHandleHandle);
opaque_handle!(ExternalSemaphoreTypeHandle);
opaque_handle!(ExternalTensorDescriptorHandle);
opaque_handle!(GetInitializerLocationFuncHandle);
opaque_handle!(GraphHandle);
opaque_handle!(GraphicsInteropConfigHandle);
opaque_handle!(HardwareDeviceHandle);
opaque_handle!(IoBindingHandle);
opaque_handle!(KernelContextHandle);
opaque_handle!(KernelCreateFuncHandle);
opaque_handle!(KernelDefBuilderHandle);
opaque_handle!(KernelDefHandle);
opaque_handle!(KernelImplHandle);
opaque_handle!(KernelInfoHandle);
opaque_handle!(KernelRegistryHandle);
opaque_handle!(KeyValuePairsHandle);
opaque_handle!(LoggerHandle);
opaque_handle!(LoopKernelHelperHandle);
opaque_handle!(LoraAdapterHandle);
opaque_handle!(MIGraphXProviderOptionsHandle);
opaque_handle!(MapTypeInfoHandle);
opaque_handle!(MemoryDeviceHandle);
opaque_handle!(MemoryInfoDeviceTypeHandle);
opaque_handle!(MemoryInfoHandle);
opaque_handle!(ModelCompilationOptionsHandle);
opaque_handle!(ModelHandle);
opaque_handle!(ModelMetadataHandle);
opaque_handle!(NodeComputeContextHandle);
opaque_handle!(NodeFusionOptionsHandle);
opaque_handle!(NodeHandle);
opaque_handle!(OpAttrHandle);
opaque_handle!(OpHandle);
opaque_handle!(OpSchemaHandle);
opaque_handle!(OpSchemaTypeConstraintHandle);
opaque_handle!(OpenVINOProviderOptionsHandle);
opaque_handle!(OptionalTypeInfoHandle);
opaque_handle!(PrepackedWeightsContainerHandle);
opaque_handle!(ProfilingEventCategoryHandle);
opaque_handle!(ProfilingEventHandle);
opaque_handle!(ProfilingEventsContainerHandle);
opaque_handle!(ROCMProviderOptionsHandle);
opaque_handle!(ReleaseExternalMemoryHandle);
opaque_handle!(ReleaseExternalSemaphoreHandle);
opaque_handle!(RunOptionsHandle);
opaque_handle!(ScanKernelHelperHandle);
opaque_handle!(SequenceTypeInfoHandle);
opaque_handle!(SessionHandle);
opaque_handle!(SessionOptionsHandle);
opaque_handle!(ShapeInferContextHandle);
opaque_handle!(SharedPrePackedWeightCacheHandle);
opaque_handle!(StatusHandle);
opaque_handle!(SyncStreamHandle);
opaque_handle!(SyncStreamImplHandle);
opaque_handle!(SyncStream_GetHandle);
opaque_handle!(TensorRTProviderOptionsHandle);
opaque_handle!(TensorRTProviderOptionsV2Handle);
opaque_handle!(TensorTypeAndShapeInfoHandle);
opaque_handle!(ThreadPoolCallbacksConfigHandle);
opaque_handle!(ThreadingOptionsHandle);
opaque_handle!(TrainingApiHandle);
opaque_handle!(TypeInfoHandle);
opaque_handle!(ValueHandle);
opaque_handle!(ValueInfoHandle);
opaque_handle!(WriteBufferFuncHandle);

/// ORT worker loop passed to a custom thread manager.
pub type ThreadWorkerFn = unsafe extern "C" fn(ort_worker_fn_param: *mut core::ffi::c_void);

#[repr(C)]
pub struct CustomThreadHandleOpaque(crate::private::Opaque);

/// Opaque thread handle returned by a custom thread creation callback and later passed to the
/// matching join callback.
pub type CustomThreadHandle = *const CustomThreadHandleOpaque;

/// ORT custom thread creation callback.
pub type CustomCreateThreadFnHandle = Option<
    unsafe extern "C" fn(
        ort_custom_thread_creation_options: *mut core::ffi::c_void,
        ort_thread_worker_fn: ThreadWorkerFn,
        ort_worker_fn_param: *mut core::ffi::c_void,
    ) -> CustomThreadHandle,
>;

/// ORT custom thread join callback.
pub type CustomJoinThreadFnHandle =
    Option<unsafe extern "C" fn(ort_custom_thread_handle: CustomThreadHandle)>;

/// `OrtStatus*` returned by ORT — null means success. Pointee is StatusHandle.
pub type StatusPtr = *mut StatusHandle;

// ── core (always available) ─────────────────────────────────────────────
// OrtStatus*(* CreateStatus)(OrtErrorCode code, const char* msg) __attribute__((nonnull))
pub const IDX_CREATE_STATUS: usize = 0;
pub type CreateStatusFn = unsafe extern "C" fn(
    code: core::ffi::c_int,
    msg: *const core::ffi::c_char,
) -> *mut StatusHandle;
impl Api {
    #[inline]
    pub unsafe fn create_status(&self) -> CreateStatusFn {
        self.f(IDX_CREATE_STATUS)
    }
}

// OrtErrorCode(* GetErrorCode)( const OrtStatus* status) __attribute__((nonnull))
pub const IDX_GET_ERROR_CODE: usize = 1;
pub type GetErrorCodeFn = unsafe extern "C" fn(status: *const StatusHandle) -> core::ffi::c_int;
impl Api {
    #[inline]
    pub unsafe fn get_error_code(&self) -> GetErrorCodeFn {
        self.f(IDX_GET_ERROR_CODE)
    }
}

// const char*(* GetErrorMessage)( const OrtStatus* status) __attribute__((nonnull))
pub const IDX_GET_ERROR_MESSAGE: usize = 2;
pub type GetErrorMessageFn =
    unsafe extern "C" fn(status: *const StatusHandle) -> *const core::ffi::c_char;
impl Api {
    #[inline]
    pub unsafe fn get_error_message(&self) -> GetErrorMessageFn {
        self.f(IDX_GET_ERROR_MESSAGE)
    }
}

// OrtStatusPtr(* CreateEnv)(OrtLoggingLevel log_severity_level, const char* logid, OrtEnv** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_ENV: usize = 3;
pub type CreateEnvFn = unsafe extern "C" fn(
    log_severity_level: LoggingLevel,
    logid: *const core::ffi::c_char,
    out_: *mut *mut EnvHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_env(&self) -> CreateEnvFn {
        self.f(IDX_CREATE_ENV)
    }
}

// OrtStatusPtr(* CreateEnvWithCustomLogger)( OrtLoggingFunction logging_function, void* logger_param, OrtLoggingLevel log_severity_level, const char* logid, OrtEnv** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_ENV_WITH_CUSTOM_LOGGER: usize = 4;
pub type CreateEnvWithCustomLoggerFn = unsafe extern "C" fn(
    logging_function: LoggingFunction,
    logger_param: *mut core::ffi::c_void,
    log_severity_level: LoggingLevel,
    logid: *const core::ffi::c_char,
    out_: *mut *mut EnvHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_env_with_custom_logger(&self) -> CreateEnvWithCustomLoggerFn {
        self.f(IDX_CREATE_ENV_WITH_CUSTOM_LOGGER)
    }
}

// OrtStatusPtr(* EnableTelemetryEvents)( const OrtEnv* env) __attribute__((warn_unused_result))
pub const IDX_ENABLE_TELEMETRY_EVENTS: usize = 5;
pub type EnableTelemetryEventsFn = unsafe extern "C" fn(env: *const EnvHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn enable_telemetry_events(&self) -> EnableTelemetryEventsFn {
        self.f(IDX_ENABLE_TELEMETRY_EVENTS)
    }
}

// OrtStatusPtr(* DisableTelemetryEvents)( const OrtEnv* env) __attribute__((warn_unused_result))
pub const IDX_DISABLE_TELEMETRY_EVENTS: usize = 6;
pub type DisableTelemetryEventsFn = unsafe extern "C" fn(env: *const EnvHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn disable_telemetry_events(&self) -> DisableTelemetryEventsFn {
        self.f(IDX_DISABLE_TELEMETRY_EVENTS)
    }
}

// OrtStatusPtr(* CreateSession)( const OrtEnv* env, const char* model_path, const OrtSessionOptions* options, OrtSession** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_SESSION: usize = 7;
pub type CreateSessionFn = unsafe extern "C" fn(
    env: *const EnvHandle,
    model_path: *const core::ffi::c_char,
    options: *const SessionOptionsHandle,
    out_: *mut *mut SessionHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_session(&self) -> CreateSessionFn {
        self.f(IDX_CREATE_SESSION)
    }
}

// OrtStatusPtr(* CreateSessionFromArray)( const OrtEnv* env, const void* model_data, size_t model_data_length, const OrtSessionOptions* options, OrtSession** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_SESSION_FROM_ARRAY: usize = 8;
pub type CreateSessionFromArrayFn = unsafe extern "C" fn(
    env: *const EnvHandle,
    model_data: *const core::ffi::c_void,
    model_data_length: usize,
    options: *const SessionOptionsHandle,
    out_: *mut *mut SessionHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_session_from_array(&self) -> CreateSessionFromArrayFn {
        self.f(IDX_CREATE_SESSION_FROM_ARRAY)
    }
}

// OrtStatusPtr(* Run)( OrtSession* session, const OrtRunOptions* run_options, const char* const* input_names, const OrtValue* const* inputs, size_t input_len, const char* const* output_names, size_t output_names_len, OrtValue** outputs) __attribute__((warn_unused_result))
pub const IDX_RUN: usize = 9;
pub type RunFn = unsafe extern "C" fn(
    session: *mut SessionHandle,
    run_options: *const RunOptionsHandle,
    input_names: *const *const core::ffi::c_char,
    inputs: *const *const ValueHandle,
    input_len: usize,
    output_names: *const *const core::ffi::c_char,
    output_names_len: usize,
    outputs: *mut *mut ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run(&self) -> RunFn {
        self.f(IDX_RUN)
    }
}

// OrtStatusPtr(* CreateSessionOptions)( OrtSessionOptions** options) __attribute__((warn_unused_result))
pub const IDX_CREATE_SESSION_OPTIONS: usize = 10;
pub type CreateSessionOptionsFn =
    unsafe extern "C" fn(options: *mut *mut SessionOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_session_options(&self) -> CreateSessionOptionsFn {
        self.f(IDX_CREATE_SESSION_OPTIONS)
    }
}

// OrtStatusPtr(* SetOptimizedModelFilePath)( OrtSessionOptions* options, const char* optimized_model_filepath) __attribute__((warn_unused_result))
pub const IDX_SET_OPTIMIZED_MODEL_FILE_PATH: usize = 11;
pub type SetOptimizedModelFilePathFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    optimized_model_filepath: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_optimized_model_file_path(&self) -> SetOptimizedModelFilePathFn {
        self.f(IDX_SET_OPTIMIZED_MODEL_FILE_PATH)
    }
}

// OrtStatusPtr(* CloneSessionOptions)( const OrtSessionOptions* in_options, OrtSessionOptions** out_options) __attribute__((warn_unused_result))
pub const IDX_CLONE_SESSION_OPTIONS: usize = 12;
pub type CloneSessionOptionsFn = unsafe extern "C" fn(
    in_options: *const SessionOptionsHandle,
    out_options: *mut *mut SessionOptionsHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn clone_session_options(&self) -> CloneSessionOptionsFn {
        self.f(IDX_CLONE_SESSION_OPTIONS)
    }
}

// OrtStatusPtr(* SetSessionExecutionMode)( OrtSessionOptions* options, ExecutionMode execution_mode) __attribute__((warn_unused_result))
pub const IDX_SET_SESSION_EXECUTION_MODE: usize = 13;
pub type SetSessionExecutionModeFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    execution_mode: ExecutionMode,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_session_execution_mode(&self) -> SetSessionExecutionModeFn {
        self.f(IDX_SET_SESSION_EXECUTION_MODE)
    }
}

// OrtStatusPtr(* EnableProfiling)( OrtSessionOptions* options, const char* profile_file_prefix) __attribute__((warn_unused_result))
pub const IDX_ENABLE_PROFILING: usize = 14;
pub type EnableProfilingFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    profile_file_prefix: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn enable_profiling(&self) -> EnableProfilingFn {
        self.f(IDX_ENABLE_PROFILING)
    }
}

// OrtStatusPtr(* DisableProfiling)( OrtSessionOptions* options) __attribute__((warn_unused_result))
pub const IDX_DISABLE_PROFILING: usize = 15;
pub type DisableProfilingFn = unsafe extern "C" fn(options: *mut SessionOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn disable_profiling(&self) -> DisableProfilingFn {
        self.f(IDX_DISABLE_PROFILING)
    }
}

// OrtStatusPtr(* EnableMemPattern)( OrtSessionOptions* options) __attribute__((warn_unused_result))
pub const IDX_ENABLE_MEM_PATTERN: usize = 16;
pub type EnableMemPatternFn = unsafe extern "C" fn(options: *mut SessionOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn enable_mem_pattern(&self) -> EnableMemPatternFn {
        self.f(IDX_ENABLE_MEM_PATTERN)
    }
}

// OrtStatusPtr(* DisableMemPattern)( OrtSessionOptions* options) __attribute__((warn_unused_result))
pub const IDX_DISABLE_MEM_PATTERN: usize = 17;
pub type DisableMemPatternFn =
    unsafe extern "C" fn(options: *mut SessionOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn disable_mem_pattern(&self) -> DisableMemPatternFn {
        self.f(IDX_DISABLE_MEM_PATTERN)
    }
}

// OrtStatusPtr(* EnableCpuMemArena)( OrtSessionOptions* options) __attribute__((warn_unused_result))
pub const IDX_ENABLE_CPU_MEM_ARENA: usize = 18;
pub type EnableCpuMemArenaFn =
    unsafe extern "C" fn(options: *mut SessionOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn enable_cpu_mem_arena(&self) -> EnableCpuMemArenaFn {
        self.f(IDX_ENABLE_CPU_MEM_ARENA)
    }
}

// OrtStatusPtr(* DisableCpuMemArena)( OrtSessionOptions* options) __attribute__((warn_unused_result))
pub const IDX_DISABLE_CPU_MEM_ARENA: usize = 19;
pub type DisableCpuMemArenaFn =
    unsafe extern "C" fn(options: *mut SessionOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn disable_cpu_mem_arena(&self) -> DisableCpuMemArenaFn {
        self.f(IDX_DISABLE_CPU_MEM_ARENA)
    }
}

// OrtStatusPtr(* SetSessionLogId)( OrtSessionOptions* options, const char* logid) __attribute__((warn_unused_result))
pub const IDX_SET_SESSION_LOG_ID: usize = 20;
pub type SetSessionLogIdFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    logid: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_session_log_id(&self) -> SetSessionLogIdFn {
        self.f(IDX_SET_SESSION_LOG_ID)
    }
}

// OrtStatusPtr(* SetSessionLogVerbosityLevel)( OrtSessionOptions* options, int session_log_verbosity_level) __attribute__((warn_unused_result))
pub const IDX_SET_SESSION_LOG_VERBOSITY_LEVEL: usize = 21;
pub type SetSessionLogVerbosityLevelFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    session_log_verbosity_level: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_session_log_verbosity_level(&self) -> SetSessionLogVerbosityLevelFn {
        self.f(IDX_SET_SESSION_LOG_VERBOSITY_LEVEL)
    }
}

// OrtStatusPtr(* SetSessionLogSeverityLevel)( OrtSessionOptions* options, int session_log_severity_level) __attribute__((warn_unused_result))
pub const IDX_SET_SESSION_LOG_SEVERITY_LEVEL: usize = 22;
pub type SetSessionLogSeverityLevelFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    session_log_severity_level: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_session_log_severity_level(&self) -> SetSessionLogSeverityLevelFn {
        self.f(IDX_SET_SESSION_LOG_SEVERITY_LEVEL)
    }
}

// OrtStatusPtr(* SetSessionGraphOptimizationLevel)( OrtSessionOptions* options, GraphOptimizationLevel graph_optimization_level) __attribute__((warn_unused_result))
pub const IDX_SET_SESSION_GRAPH_OPTIMIZATION_LEVEL: usize = 23;
pub type SetSessionGraphOptimizationLevelFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    graph_optimization_level: GraphOptimizationLevel,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_session_graph_optimization_level(
        &self,
    ) -> SetSessionGraphOptimizationLevelFn {
        self.f(IDX_SET_SESSION_GRAPH_OPTIMIZATION_LEVEL)
    }
}

// OrtStatusPtr(* SetIntraOpNumThreads)( OrtSessionOptions* options, int intra_op_num_threads) __attribute__((warn_unused_result))
pub const IDX_SET_INTRA_OP_NUM_THREADS: usize = 24;
pub type SetIntraOpNumThreadsFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    intra_op_num_threads: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_intra_op_num_threads(&self) -> SetIntraOpNumThreadsFn {
        self.f(IDX_SET_INTRA_OP_NUM_THREADS)
    }
}

// OrtStatusPtr(* SetInterOpNumThreads)( OrtSessionOptions* options, int inter_op_num_threads) __attribute__((warn_unused_result))
pub const IDX_SET_INTER_OP_NUM_THREADS: usize = 25;
pub type SetInterOpNumThreadsFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    inter_op_num_threads: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_inter_op_num_threads(&self) -> SetInterOpNumThreadsFn {
        self.f(IDX_SET_INTER_OP_NUM_THREADS)
    }
}

// OrtStatusPtr(* CreateCustomOpDomain)( const char* domain, OrtCustomOpDomain** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_CUSTOM_OP_DOMAIN: usize = 26;
pub type CreateCustomOpDomainFn = unsafe extern "C" fn(
    domain: *const core::ffi::c_char,
    out_: *mut *mut CustomOpDomainHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_custom_op_domain(&self) -> CreateCustomOpDomainFn {
        self.f(IDX_CREATE_CUSTOM_OP_DOMAIN)
    }
}

// OrtStatusPtr(* AddCustomOpDomain)( OrtSessionOptions* options, OrtCustomOpDomain* custom_op_domain) __attribute__((warn_unused_result))
pub const IDX_ADD_CUSTOM_OP_DOMAIN: usize = 28;
pub type AddCustomOpDomainFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    custom_op_domain: *mut CustomOpDomainHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn add_custom_op_domain(&self) -> AddCustomOpDomainFn {
        self.f(IDX_ADD_CUSTOM_OP_DOMAIN)
    }
}

// OrtStatusPtr(* RegisterCustomOpsLibrary)( OrtSessionOptions* options, const char* library_path, void** library_handle) __attribute__((warn_unused_result))
pub const IDX_REGISTER_CUSTOM_OPS_LIBRARY: usize = 29;
pub type RegisterCustomOpsLibraryFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    library_path: *const core::ffi::c_char,
    library_handle: *mut *mut core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn register_custom_ops_library(&self) -> RegisterCustomOpsLibraryFn {
        self.f(IDX_REGISTER_CUSTOM_OPS_LIBRARY)
    }
}

// OrtStatusPtr(* SessionGetInputCount)( const OrtSession* session, size_t* out) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_INPUT_COUNT: usize = 30;
pub type SessionGetInputCountFn =
    unsafe extern "C" fn(session: *const SessionHandle, out_: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_input_count(&self) -> SessionGetInputCountFn {
        self.f(IDX_SESSION_GET_INPUT_COUNT)
    }
}

// OrtStatusPtr(* SessionGetOutputCount)( const OrtSession* session, size_t* out) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_OUTPUT_COUNT: usize = 31;
pub type SessionGetOutputCountFn =
    unsafe extern "C" fn(session: *const SessionHandle, out_: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_output_count(&self) -> SessionGetOutputCountFn {
        self.f(IDX_SESSION_GET_OUTPUT_COUNT)
    }
}

// OrtStatusPtr(* SessionGetOverridableInitializerCount)( const OrtSession* session, size_t* out) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_OVERRIDABLE_INITIALIZER_COUNT: usize = 32;
pub type SessionGetOverridableInitializerCountFn =
    unsafe extern "C" fn(session: *const SessionHandle, out_: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_overridable_initializer_count(
        &self,
    ) -> SessionGetOverridableInitializerCountFn {
        self.f(IDX_SESSION_GET_OVERRIDABLE_INITIALIZER_COUNT)
    }
}

// OrtStatusPtr(* SessionGetInputTypeInfo)( const OrtSession* session, size_t index, OrtTypeInfo** type_info) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_INPUT_TYPE_INFO: usize = 33;
pub type SessionGetInputTypeInfoFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    index: usize,
    type_info: *mut *mut TypeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_input_type_info(&self) -> SessionGetInputTypeInfoFn {
        self.f(IDX_SESSION_GET_INPUT_TYPE_INFO)
    }
}

// OrtStatusPtr(* SessionGetOutputTypeInfo)( const OrtSession* session, size_t index, OrtTypeInfo** type_info) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_OUTPUT_TYPE_INFO: usize = 34;
pub type SessionGetOutputTypeInfoFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    index: usize,
    type_info: *mut *mut TypeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_output_type_info(&self) -> SessionGetOutputTypeInfoFn {
        self.f(IDX_SESSION_GET_OUTPUT_TYPE_INFO)
    }
}

// OrtStatusPtr(* SessionGetOverridableInitializerTypeInfo)( const OrtSession* session, size_t index, OrtTypeInfo** type_info) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_OVERRIDABLE_INITIALIZER_TYPE_INFO: usize = 35;
pub type SessionGetOverridableInitializerTypeInfoFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    index: usize,
    type_info: *mut *mut TypeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_overridable_initializer_type_info(
        &self,
    ) -> SessionGetOverridableInitializerTypeInfoFn {
        self.f(IDX_SESSION_GET_OVERRIDABLE_INITIALIZER_TYPE_INFO)
    }
}

// OrtStatusPtr(* SessionGetInputName)( const OrtSession* session, size_t index, OrtAllocator* allocator, char** value) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_INPUT_NAME: usize = 36;
pub type SessionGetInputNameFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    index: usize,
    allocator: *mut AllocatorHandle,
    value: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_input_name(&self) -> SessionGetInputNameFn {
        self.f(IDX_SESSION_GET_INPUT_NAME)
    }
}

// OrtStatusPtr(* SessionGetOutputName)( const OrtSession* session, size_t index, OrtAllocator* allocator, char** value) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_OUTPUT_NAME: usize = 37;
pub type SessionGetOutputNameFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    index: usize,
    allocator: *mut AllocatorHandle,
    value: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_output_name(&self) -> SessionGetOutputNameFn {
        self.f(IDX_SESSION_GET_OUTPUT_NAME)
    }
}

// OrtStatusPtr(* SessionGetOverridableInitializerName)( const OrtSession* session, size_t index, OrtAllocator* allocator, char** value) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_OVERRIDABLE_INITIALIZER_NAME: usize = 38;
pub type SessionGetOverridableInitializerNameFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    index: usize,
    allocator: *mut AllocatorHandle,
    value: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_overridable_initializer_name(
        &self,
    ) -> SessionGetOverridableInitializerNameFn {
        self.f(IDX_SESSION_GET_OVERRIDABLE_INITIALIZER_NAME)
    }
}

// OrtStatusPtr(* CreateRunOptions)( OrtRunOptions** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_RUN_OPTIONS: usize = 39;
pub type CreateRunOptionsFn = unsafe extern "C" fn(out_: *mut *mut RunOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_run_options(&self) -> CreateRunOptionsFn {
        self.f(IDX_CREATE_RUN_OPTIONS)
    }
}

// OrtStatusPtr(* RunOptionsSetRunLogVerbosityLevel)( OrtRunOptions* options, int log_verbosity_level) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_SET_RUN_LOG_VERBOSITY_LEVEL: usize = 40;
pub type RunOptionsSetRunLogVerbosityLevelFn = unsafe extern "C" fn(
    options: *mut RunOptionsHandle,
    log_verbosity_level: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_set_run_log_verbosity_level(
        &self,
    ) -> RunOptionsSetRunLogVerbosityLevelFn {
        self.f(IDX_RUN_OPTIONS_SET_RUN_LOG_VERBOSITY_LEVEL)
    }
}

// OrtStatusPtr(* RunOptionsSetRunLogSeverityLevel)( OrtRunOptions* options, int log_severity_level) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_SET_RUN_LOG_SEVERITY_LEVEL: usize = 41;
pub type RunOptionsSetRunLogSeverityLevelFn = unsafe extern "C" fn(
    options: *mut RunOptionsHandle,
    log_severity_level: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_set_run_log_severity_level(
        &self,
    ) -> RunOptionsSetRunLogSeverityLevelFn {
        self.f(IDX_RUN_OPTIONS_SET_RUN_LOG_SEVERITY_LEVEL)
    }
}

// OrtStatusPtr(* RunOptionsSetRunTag)( OrtRunOptions* options, const char* run_tag) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_SET_RUN_TAG: usize = 42;
pub type RunOptionsSetRunTagFn = unsafe extern "C" fn(
    options: *mut RunOptionsHandle,
    run_tag: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_set_run_tag(&self) -> RunOptionsSetRunTagFn {
        self.f(IDX_RUN_OPTIONS_SET_RUN_TAG)
    }
}

// OrtStatusPtr(* RunOptionsGetRunLogVerbosityLevel)( const OrtRunOptions* options, int* log_verbosity_level) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_GET_RUN_LOG_VERBOSITY_LEVEL: usize = 43;
pub type RunOptionsGetRunLogVerbosityLevelFn = unsafe extern "C" fn(
    options: *const RunOptionsHandle,
    log_verbosity_level: *mut core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_get_run_log_verbosity_level(
        &self,
    ) -> RunOptionsGetRunLogVerbosityLevelFn {
        self.f(IDX_RUN_OPTIONS_GET_RUN_LOG_VERBOSITY_LEVEL)
    }
}

// OrtStatusPtr(* RunOptionsGetRunLogSeverityLevel)( const OrtRunOptions* options, int* log_severity_level) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_GET_RUN_LOG_SEVERITY_LEVEL: usize = 44;
pub type RunOptionsGetRunLogSeverityLevelFn = unsafe extern "C" fn(
    options: *const RunOptionsHandle,
    log_severity_level: *mut core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_get_run_log_severity_level(
        &self,
    ) -> RunOptionsGetRunLogSeverityLevelFn {
        self.f(IDX_RUN_OPTIONS_GET_RUN_LOG_SEVERITY_LEVEL)
    }
}

// OrtStatusPtr(* RunOptionsGetRunTag)( const OrtRunOptions* options, const char** run_tag) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_GET_RUN_TAG: usize = 45;
pub type RunOptionsGetRunTagFn = unsafe extern "C" fn(
    options: *const RunOptionsHandle,
    run_tag: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_get_run_tag(&self) -> RunOptionsGetRunTagFn {
        self.f(IDX_RUN_OPTIONS_GET_RUN_TAG)
    }
}

// OrtStatusPtr(* RunOptionsSetTerminate)( OrtRunOptions* options) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_SET_TERMINATE: usize = 46;
pub type RunOptionsSetTerminateFn =
    unsafe extern "C" fn(options: *mut RunOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_set_terminate(&self) -> RunOptionsSetTerminateFn {
        self.f(IDX_RUN_OPTIONS_SET_TERMINATE)
    }
}

// OrtStatusPtr(* RunOptionsUnsetTerminate)( OrtRunOptions* options) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_UNSET_TERMINATE: usize = 47;
pub type RunOptionsUnsetTerminateFn =
    unsafe extern "C" fn(options: *mut RunOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_unset_terminate(&self) -> RunOptionsUnsetTerminateFn {
        self.f(IDX_RUN_OPTIONS_UNSET_TERMINATE)
    }
}

// OrtStatusPtr(* CreateTensorAsOrtValue)( OrtAllocator* allocator, const int64_t* shape, size_t shape_len, ONNXTensorElementDataType type, OrtValue** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_TENSOR_AS_ORT_VALUE: usize = 48;
pub type CreateTensorAsOrtValueFn = unsafe extern "C" fn(
    allocator: *mut AllocatorHandle,
    shape: *const i64,
    shape_len: usize,
    type_: ElementType,
    out_: *mut *mut ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_tensor_as_ort_value(&self) -> CreateTensorAsOrtValueFn {
        self.f(IDX_CREATE_TENSOR_AS_ORT_VALUE)
    }
}

// OrtStatusPtr(* CreateTensorWithDataAsOrtValue)( const OrtMemoryInfo* info, void* p_data, size_t p_data_len, const int64_t* shape, size_t shape_len, ONNXTensorElementDataType type, OrtValue** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_TENSOR_WITH_DATA_AS_ORT_VALUE: usize = 49;
pub type CreateTensorWithDataAsOrtValueFn = unsafe extern "C" fn(
    info: *const MemoryInfoHandle,
    p_data: *mut core::ffi::c_void,
    p_data_len: usize,
    shape: *const i64,
    shape_len: usize,
    type_: ElementType,
    out_: *mut *mut ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_tensor_with_data_as_ort_value(&self) -> CreateTensorWithDataAsOrtValueFn {
        self.f(IDX_CREATE_TENSOR_WITH_DATA_AS_ORT_VALUE)
    }
}

// OrtStatusPtr(* IsTensor)( const OrtValue* value, int* out) __attribute__((warn_unused_result))
pub const IDX_IS_TENSOR: usize = 50;
pub type IsTensorFn =
    unsafe extern "C" fn(value: *const ValueHandle, out_: *mut core::ffi::c_int) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn is_tensor(&self) -> IsTensorFn {
        self.f(IDX_IS_TENSOR)
    }
}

// OrtStatusPtr(* GetTensorMutableData)( OrtValue* value, void** out) __attribute__((warn_unused_result))
pub const IDX_GET_TENSOR_MUTABLE_DATA: usize = 51;
pub type GetTensorMutableDataFn =
    unsafe extern "C" fn(value: *mut ValueHandle, out_: *mut *mut core::ffi::c_void) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_tensor_mutable_data(&self) -> GetTensorMutableDataFn {
        self.f(IDX_GET_TENSOR_MUTABLE_DATA)
    }
}

// OrtStatusPtr(* FillStringTensor)( OrtValue* value, const char* const* s, size_t s_len) __attribute__((warn_unused_result))
pub const IDX_FILL_STRING_TENSOR: usize = 52;
pub type FillStringTensorFn = unsafe extern "C" fn(
    value: *mut ValueHandle,
    s: *const *const core::ffi::c_char,
    s_len: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn fill_string_tensor(&self) -> FillStringTensorFn {
        self.f(IDX_FILL_STRING_TENSOR)
    }
}

// OrtStatusPtr(* GetStringTensorDataLength)( const OrtValue* value, size_t* len) __attribute__((warn_unused_result))
pub const IDX_GET_STRING_TENSOR_DATA_LENGTH: usize = 53;
pub type GetStringTensorDataLengthFn =
    unsafe extern "C" fn(value: *const ValueHandle, len: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_string_tensor_data_length(&self) -> GetStringTensorDataLengthFn {
        self.f(IDX_GET_STRING_TENSOR_DATA_LENGTH)
    }
}

// OrtStatusPtr(* GetStringTensorContent)( const OrtValue* value, void* s, size_t s_len, size_t* offsets, size_t offsets_len) __attribute__((warn_unused_result))
pub const IDX_GET_STRING_TENSOR_CONTENT: usize = 54;
pub type GetStringTensorContentFn = unsafe extern "C" fn(
    value: *const ValueHandle,
    s: *mut core::ffi::c_void,
    s_len: usize,
    offsets: *mut usize,
    offsets_len: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_string_tensor_content(&self) -> GetStringTensorContentFn {
        self.f(IDX_GET_STRING_TENSOR_CONTENT)
    }
}

// OrtStatusPtr(* CastTypeInfoToTensorInfo)( const OrtTypeInfo* type_info, const OrtTensorTypeAndShapeInfo** out) __attribute__((warn_unused_result))
pub const IDX_CAST_TYPE_INFO_TO_TENSOR_INFO: usize = 55;
pub type CastTypeInfoToTensorInfoFn = unsafe extern "C" fn(
    type_info: *const TypeInfoHandle,
    out_: *const *const TensorTypeAndShapeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn cast_type_info_to_tensor_info(&self) -> CastTypeInfoToTensorInfoFn {
        self.f(IDX_CAST_TYPE_INFO_TO_TENSOR_INFO)
    }
}

// OrtStatusPtr(* GetOnnxTypeFromTypeInfo)( const OrtTypeInfo* type_info, enum ONNXType* out) __attribute__((warn_unused_result))
pub const IDX_GET_ONNX_TYPE_FROM_TYPE_INFO: usize = 56;
pub type GetOnnxTypeFromTypeInfoFn =
    unsafe extern "C" fn(type_info: *const TypeInfoHandle, out_: *mut OnnxType) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_onnx_type_from_type_info(&self) -> GetOnnxTypeFromTypeInfoFn {
        self.f(IDX_GET_ONNX_TYPE_FROM_TYPE_INFO)
    }
}

// OrtStatusPtr(* CreateTensorTypeAndShapeInfo)( OrtTensorTypeAndShapeInfo** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_TENSOR_TYPE_AND_SHAPE_INFO: usize = 57;
pub type CreateTensorTypeAndShapeInfoFn =
    unsafe extern "C" fn(out_: *mut *mut TensorTypeAndShapeInfoHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_tensor_type_and_shape_info(&self) -> CreateTensorTypeAndShapeInfoFn {
        self.f(IDX_CREATE_TENSOR_TYPE_AND_SHAPE_INFO)
    }
}

// OrtStatusPtr(* SetTensorElementType)( OrtTensorTypeAndShapeInfo* info, enum ONNXTensorElementDataType type) __attribute__((warn_unused_result))
pub const IDX_SET_TENSOR_ELEMENT_TYPE: usize = 58;
pub type SetTensorElementTypeFn =
    unsafe extern "C" fn(info: *mut TensorTypeAndShapeInfoHandle, type_: ElementType) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_tensor_element_type(&self) -> SetTensorElementTypeFn {
        self.f(IDX_SET_TENSOR_ELEMENT_TYPE)
    }
}

// OrtStatusPtr(* SetDimensions)(OrtTensorTypeAndShapeInfo* info, const int64_t* dim_values, size_t dim_count) __attribute__((warn_unused_result))
pub const IDX_SET_DIMENSIONS: usize = 59;
pub type SetDimensionsFn = unsafe extern "C" fn(
    info: *mut TensorTypeAndShapeInfoHandle,
    dim_values: *const i64,
    dim_count: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_dimensions(&self) -> SetDimensionsFn {
        self.f(IDX_SET_DIMENSIONS)
    }
}

// OrtStatusPtr(* GetTensorElementType)( const OrtTensorTypeAndShapeInfo* info, enum ONNXTensorElementDataType* out) __attribute__((warn_unused_result))
pub const IDX_GET_TENSOR_ELEMENT_TYPE: usize = 60;
pub type GetTensorElementTypeFn = unsafe extern "C" fn(
    info: *const TensorTypeAndShapeInfoHandle,
    out_: *mut ElementType,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_tensor_element_type(&self) -> GetTensorElementTypeFn {
        self.f(IDX_GET_TENSOR_ELEMENT_TYPE)
    }
}

// OrtStatusPtr(* GetDimensionsCount)( const OrtTensorTypeAndShapeInfo* info, size_t* out) __attribute__((warn_unused_result))
pub const IDX_GET_DIMENSIONS_COUNT: usize = 61;
pub type GetDimensionsCountFn =
    unsafe extern "C" fn(info: *const TensorTypeAndShapeInfoHandle, out_: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_dimensions_count(&self) -> GetDimensionsCountFn {
        self.f(IDX_GET_DIMENSIONS_COUNT)
    }
}

// OrtStatusPtr(* GetDimensions)( const OrtTensorTypeAndShapeInfo* info, int64_t* dim_values, size_t dim_values_length) __attribute__((warn_unused_result))
pub const IDX_GET_DIMENSIONS: usize = 62;
pub type GetDimensionsFn = unsafe extern "C" fn(
    info: *const TensorTypeAndShapeInfoHandle,
    dim_values: *mut i64,
    dim_values_length: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_dimensions(&self) -> GetDimensionsFn {
        self.f(IDX_GET_DIMENSIONS)
    }
}

// OrtStatusPtr(* GetSymbolicDimensions)( const OrtTensorTypeAndShapeInfo* info, const char* dim_params[], size_t dim_params_length) __attribute__((warn_unused_result))
pub const IDX_GET_SYMBOLIC_DIMENSIONS: usize = 63;
pub type GetSymbolicDimensionsFn = unsafe extern "C" fn(
    info: *const TensorTypeAndShapeInfoHandle,
    dim_params: *const *const core::ffi::c_char,
    dim_params_length: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_symbolic_dimensions(&self) -> GetSymbolicDimensionsFn {
        self.f(IDX_GET_SYMBOLIC_DIMENSIONS)
    }
}

// OrtStatusPtr(* GetTensorShapeElementCount)( const OrtTensorTypeAndShapeInfo* info, size_t* out) __attribute__((warn_unused_result))
pub const IDX_GET_TENSOR_SHAPE_ELEMENT_COUNT: usize = 64;
pub type GetTensorShapeElementCountFn =
    unsafe extern "C" fn(info: *const TensorTypeAndShapeInfoHandle, out_: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_tensor_shape_element_count(&self) -> GetTensorShapeElementCountFn {
        self.f(IDX_GET_TENSOR_SHAPE_ELEMENT_COUNT)
    }
}

// OrtStatusPtr(* GetTensorTypeAndShape)( const OrtValue* value, OrtTensorTypeAndShapeInfo** out) __attribute__((warn_unused_result))
pub const IDX_GET_TENSOR_TYPE_AND_SHAPE: usize = 65;
pub type GetTensorTypeAndShapeFn = unsafe extern "C" fn(
    value: *const ValueHandle,
    out_: *mut *mut TensorTypeAndShapeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_tensor_type_and_shape(&self) -> GetTensorTypeAndShapeFn {
        self.f(IDX_GET_TENSOR_TYPE_AND_SHAPE)
    }
}

// OrtStatusPtr(* GetTypeInfo)( const OrtValue* value, OrtTypeInfo** out) __attribute__((warn_unused_result))
pub const IDX_GET_TYPE_INFO: usize = 66;
pub type GetTypeInfoFn =
    unsafe extern "C" fn(value: *const ValueHandle, out_: *mut *mut TypeInfoHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_type_info(&self) -> GetTypeInfoFn {
        self.f(IDX_GET_TYPE_INFO)
    }
}

// OrtStatusPtr(* GetValueType)( const OrtValue* value, enum ONNXType* out) __attribute__((warn_unused_result))
pub const IDX_GET_VALUE_TYPE: usize = 67;
pub type GetValueTypeFn =
    unsafe extern "C" fn(value: *const ValueHandle, out_: *mut OnnxType) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_value_type(&self) -> GetValueTypeFn {
        self.f(IDX_GET_VALUE_TYPE)
    }
}

// OrtStatusPtr(* CreateMemoryInfo)( const char* name, enum OrtAllocatorType type, int id, enum OrtMemType mem_type, OrtMemoryInfo** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_MEMORY_INFO: usize = 68;
pub type CreateMemoryInfoFn = unsafe extern "C" fn(
    name: *const core::ffi::c_char,
    type_: AllocatorType,
    id: core::ffi::c_int,
    mem_type: MemType,
    out_: *mut *mut MemoryInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_memory_info(&self) -> CreateMemoryInfoFn {
        self.f(IDX_CREATE_MEMORY_INFO)
    }
}

// OrtStatusPtr(* CreateCpuMemoryInfo)(enum OrtAllocatorType type, enum OrtMemType mem_type, OrtMemoryInfo** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_CPU_MEMORY_INFO: usize = 69;
pub type CreateCpuMemoryInfoFn = unsafe extern "C" fn(
    type_: AllocatorType,
    mem_type: MemType,
    out_: *mut *mut MemoryInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_cpu_memory_info(&self) -> CreateCpuMemoryInfoFn {
        self.f(IDX_CREATE_CPU_MEMORY_INFO)
    }
}

// OrtStatusPtr(* CompareMemoryInfo)( const OrtMemoryInfo* info1, const OrtMemoryInfo* info2, int* out) __attribute__((warn_unused_result))
pub const IDX_COMPARE_MEMORY_INFO: usize = 70;
pub type CompareMemoryInfoFn = unsafe extern "C" fn(
    info1: *const MemoryInfoHandle,
    info2: *const MemoryInfoHandle,
    out_: *mut core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn compare_memory_info(&self) -> CompareMemoryInfoFn {
        self.f(IDX_COMPARE_MEMORY_INFO)
    }
}

// OrtStatusPtr(* MemoryInfoGetName)( const OrtMemoryInfo* ptr, const char** out) __attribute__((warn_unused_result))
pub const IDX_MEMORY_INFO_GET_NAME: usize = 71;
pub type MemoryInfoGetNameFn = unsafe extern "C" fn(
    ptr: *const MemoryInfoHandle,
    out_: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn memory_info_get_name(&self) -> MemoryInfoGetNameFn {
        self.f(IDX_MEMORY_INFO_GET_NAME)
    }
}

// OrtStatusPtr(* MemoryInfoGetId)( const OrtMemoryInfo* ptr, int* out) __attribute__((warn_unused_result))
pub const IDX_MEMORY_INFO_GET_ID: usize = 72;
pub type MemoryInfoGetIdFn =
    unsafe extern "C" fn(ptr: *const MemoryInfoHandle, out_: *mut core::ffi::c_int) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn memory_info_get_id(&self) -> MemoryInfoGetIdFn {
        self.f(IDX_MEMORY_INFO_GET_ID)
    }
}

// OrtStatusPtr(* MemoryInfoGetMemType)( const OrtMemoryInfo* ptr, OrtMemType* out) __attribute__((warn_unused_result))
pub const IDX_MEMORY_INFO_GET_MEM_TYPE: usize = 73;
pub type MemoryInfoGetMemTypeFn =
    unsafe extern "C" fn(ptr: *const MemoryInfoHandle, out_: *mut MemType) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn memory_info_get_mem_type(&self) -> MemoryInfoGetMemTypeFn {
        self.f(IDX_MEMORY_INFO_GET_MEM_TYPE)
    }
}

// OrtStatusPtr(* MemoryInfoGetType)( const OrtMemoryInfo* ptr, OrtAllocatorType* out) __attribute__((warn_unused_result))
pub const IDX_MEMORY_INFO_GET_TYPE: usize = 74;
pub type MemoryInfoGetTypeFn =
    unsafe extern "C" fn(ptr: *const MemoryInfoHandle, out_: *mut AllocatorType) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn memory_info_get_type(&self) -> MemoryInfoGetTypeFn {
        self.f(IDX_MEMORY_INFO_GET_TYPE)
    }
}

// OrtStatusPtr(* AllocatorAlloc)( OrtAllocator* ort_allocator, size_t size, void** out) __attribute__((warn_unused_result))
pub const IDX_ALLOCATOR_ALLOC: usize = 75;
pub type AllocatorAllocFn = unsafe extern "C" fn(
    ort_allocator: *mut AllocatorHandle,
    size: usize,
    out_: *mut *mut core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn allocator_alloc(&self) -> AllocatorAllocFn {
        self.f(IDX_ALLOCATOR_ALLOC)
    }
}

// OrtStatusPtr(* AllocatorFree)( OrtAllocator* ort_allocator, void* p) __attribute__((warn_unused_result))
pub const IDX_ALLOCATOR_FREE: usize = 76;
pub type AllocatorFreeFn = unsafe extern "C" fn(
    ort_allocator: *mut AllocatorHandle,
    p: *mut core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn allocator_free(&self) -> AllocatorFreeFn {
        self.f(IDX_ALLOCATOR_FREE)
    }
}

// OrtStatusPtr(* AllocatorGetInfo)( const OrtAllocator* ort_allocator, const struct OrtMemoryInfo** out) __attribute__((warn_unused_result))
pub const IDX_ALLOCATOR_GET_INFO: usize = 77;
pub type AllocatorGetInfoFn = unsafe extern "C" fn(
    ort_allocator: *const AllocatorHandle,
    out_: *const *const MemoryInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn allocator_get_info(&self) -> AllocatorGetInfoFn {
        self.f(IDX_ALLOCATOR_GET_INFO)
    }
}

// OrtStatusPtr(* GetAllocatorWithDefaultOptions)( OrtAllocator** out) __attribute__((warn_unused_result))
pub const IDX_GET_ALLOCATOR_WITH_DEFAULT_OPTIONS: usize = 78;
pub type GetAllocatorWithDefaultOptionsFn =
    unsafe extern "C" fn(out_: *mut *mut AllocatorHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_allocator_with_default_options(&self) -> GetAllocatorWithDefaultOptionsFn {
        self.f(IDX_GET_ALLOCATOR_WITH_DEFAULT_OPTIONS)
    }
}

// OrtStatusPtr(* AddFreeDimensionOverride)( OrtSessionOptions* options, const char* dim_denotation, int64_t dim_value) __attribute__((warn_unused_result))
pub const IDX_ADD_FREE_DIMENSION_OVERRIDE: usize = 79;
pub type AddFreeDimensionOverrideFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    dim_denotation: *const core::ffi::c_char,
    dim_value: i64,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn add_free_dimension_override(&self) -> AddFreeDimensionOverrideFn {
        self.f(IDX_ADD_FREE_DIMENSION_OVERRIDE)
    }
}

// OrtStatusPtr(* GetValue)( const OrtValue* value, int index, OrtAllocator* allocator, OrtValue** out) __attribute__((warn_unused_result))
pub const IDX_GET_VALUE: usize = 80;
pub type GetValueFn = unsafe extern "C" fn(
    value: *const ValueHandle,
    index: core::ffi::c_int,
    allocator: *mut AllocatorHandle,
    out_: *mut *mut ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_value(&self) -> GetValueFn {
        self.f(IDX_GET_VALUE)
    }
}

// OrtStatusPtr(* GetValueCount)( const OrtValue* value, size_t* out) __attribute__((warn_unused_result))
pub const IDX_GET_VALUE_COUNT: usize = 81;
pub type GetValueCountFn =
    unsafe extern "C" fn(value: *const ValueHandle, out_: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_value_count(&self) -> GetValueCountFn {
        self.f(IDX_GET_VALUE_COUNT)
    }
}

// OrtStatusPtr(* CreateValue)( const OrtValue* const* in, size_t num_values, enum ONNXType value_type, OrtValue** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_VALUE: usize = 82;
pub type CreateValueFn = unsafe extern "C" fn(
    in_: *const *const ValueHandle,
    num_values: usize,
    value_type: OnnxType,
    out_: *mut *mut ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_value(&self) -> CreateValueFn {
        self.f(IDX_CREATE_VALUE)
    }
}

// OrtStatusPtr(* CreateOpaqueValue)( const char* domain_name, const char* type_name, const void* data_container, size_t data_container_size, OrtValue** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_OPAQUE_VALUE: usize = 83;
pub type CreateOpaqueValueFn = unsafe extern "C" fn(
    domain_name: *const core::ffi::c_char,
    type_name: *const core::ffi::c_char,
    data_container: *const core::ffi::c_void,
    data_container_size: usize,
    out_: *mut *mut ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_opaque_value(&self) -> CreateOpaqueValueFn {
        self.f(IDX_CREATE_OPAQUE_VALUE)
    }
}

// OrtStatusPtr(* GetOpaqueValue)( const char* domain_name, const char* type_name, const OrtValue* in, void* data_container, size_t data_container_size) __attribute__((warn_unused_result))
pub const IDX_GET_OPAQUE_VALUE: usize = 84;
pub type GetOpaqueValueFn = unsafe extern "C" fn(
    domain_name: *const core::ffi::c_char,
    type_name: *const core::ffi::c_char,
    in_: *const ValueHandle,
    data_container: *mut core::ffi::c_void,
    data_container_size: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_opaque_value(&self) -> GetOpaqueValueFn {
        self.f(IDX_GET_OPAQUE_VALUE)
    }
}

// void( * ReleaseEnv)( OrtEnv * input)
pub const IDX_RELEASE_ENV: usize = 92;
pub type ReleaseEnvFn = unsafe extern "C" fn(input: *mut EnvHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_env(&self) -> ReleaseEnvFn {
        self.f(IDX_RELEASE_ENV)
    }
}

// void( * ReleaseStatus)( OrtStatus * input)
pub const IDX_RELEASE_STATUS: usize = 93;
pub type ReleaseStatusFn = unsafe extern "C" fn(input: *mut StatusHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_status(&self) -> ReleaseStatusFn {
        self.f(IDX_RELEASE_STATUS)
    }
}

// void( * ReleaseMemoryInfo)( OrtMemoryInfo * input)
pub const IDX_RELEASE_MEMORY_INFO: usize = 94;
pub type ReleaseMemoryInfoFn = unsafe extern "C" fn(input: *mut MemoryInfoHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_memory_info(&self) -> ReleaseMemoryInfoFn {
        self.f(IDX_RELEASE_MEMORY_INFO)
    }
}

// void( * ReleaseSession)( OrtSession * input)
pub const IDX_RELEASE_SESSION: usize = 95;
pub type ReleaseSessionFn = unsafe extern "C" fn(input: *mut SessionHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_session(&self) -> ReleaseSessionFn {
        self.f(IDX_RELEASE_SESSION)
    }
}

// void( * ReleaseValue)( OrtValue * input)
pub const IDX_RELEASE_VALUE: usize = 96;
pub type ReleaseValueFn = unsafe extern "C" fn(input: *mut ValueHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_value(&self) -> ReleaseValueFn {
        self.f(IDX_RELEASE_VALUE)
    }
}

// void( * ReleaseRunOptions)( OrtRunOptions * input)
pub const IDX_RELEASE_RUN_OPTIONS: usize = 97;
pub type ReleaseRunOptionsFn = unsafe extern "C" fn(input: *mut RunOptionsHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_run_options(&self) -> ReleaseRunOptionsFn {
        self.f(IDX_RELEASE_RUN_OPTIONS)
    }
}

// void( * ReleaseTypeInfo)( OrtTypeInfo * input)
pub const IDX_RELEASE_TYPE_INFO: usize = 98;
pub type ReleaseTypeInfoFn = unsafe extern "C" fn(input: *mut TypeInfoHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_type_info(&self) -> ReleaseTypeInfoFn {
        self.f(IDX_RELEASE_TYPE_INFO)
    }
}

// void( * ReleaseTensorTypeAndShapeInfo)( OrtTensorTypeAndShapeInfo * input)
pub const IDX_RELEASE_TENSOR_TYPE_AND_SHAPE_INFO: usize = 99;
pub type ReleaseTensorTypeAndShapeInfoFn =
    unsafe extern "C" fn(input: *mut TensorTypeAndShapeInfoHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_tensor_type_and_shape_info(&self) -> ReleaseTensorTypeAndShapeInfoFn {
        self.f(IDX_RELEASE_TENSOR_TYPE_AND_SHAPE_INFO)
    }
}

// void( * ReleaseSessionOptions)( OrtSessionOptions * input)
pub const IDX_RELEASE_SESSION_OPTIONS: usize = 100;
pub type ReleaseSessionOptionsFn = unsafe extern "C" fn(input: *mut SessionOptionsHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_session_options(&self) -> ReleaseSessionOptionsFn {
        self.f(IDX_RELEASE_SESSION_OPTIONS)
    }
}

// void( * ReleaseCustomOpDomain)( OrtCustomOpDomain * input)
pub const IDX_RELEASE_CUSTOM_OP_DOMAIN: usize = 101;
pub type ReleaseCustomOpDomainFn = unsafe extern "C" fn(input: *mut CustomOpDomainHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_custom_op_domain(&self) -> ReleaseCustomOpDomainFn {
        self.f(IDX_RELEASE_CUSTOM_OP_DOMAIN)
    }
}

// OrtStatusPtr(* GetDenotationFromTypeInfo)( const OrtTypeInfo* type_info, const char** const denotation, size_t* len) __attribute__((warn_unused_result))
pub const IDX_GET_DENOTATION_FROM_TYPE_INFO: usize = 102;
pub type GetDenotationFromTypeInfoFn = unsafe extern "C" fn(
    type_info: *const TypeInfoHandle,
    denotation: *const *const core::ffi::c_char,
    len: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_denotation_from_type_info(&self) -> GetDenotationFromTypeInfoFn {
        self.f(IDX_GET_DENOTATION_FROM_TYPE_INFO)
    }
}

// OrtStatusPtr(* CastTypeInfoToMapTypeInfo)( const OrtTypeInfo* type_info, const OrtMapTypeInfo** out) __attribute__((warn_unused_result))
pub const IDX_CAST_TYPE_INFO_TO_MAP_TYPE_INFO: usize = 103;
pub type CastTypeInfoToMapTypeInfoFn = unsafe extern "C" fn(
    type_info: *const TypeInfoHandle,
    out_: *const *const MapTypeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn cast_type_info_to_map_type_info(&self) -> CastTypeInfoToMapTypeInfoFn {
        self.f(IDX_CAST_TYPE_INFO_TO_MAP_TYPE_INFO)
    }
}

// OrtStatusPtr(* CastTypeInfoToSequenceTypeInfo)( const OrtTypeInfo* type_info, const OrtSequenceTypeInfo** out) __attribute__((warn_unused_result))
pub const IDX_CAST_TYPE_INFO_TO_SEQUENCE_TYPE_INFO: usize = 104;
pub type CastTypeInfoToSequenceTypeInfoFn = unsafe extern "C" fn(
    type_info: *const TypeInfoHandle,
    out_: *const *const SequenceTypeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn cast_type_info_to_sequence_type_info(&self) -> CastTypeInfoToSequenceTypeInfoFn {
        self.f(IDX_CAST_TYPE_INFO_TO_SEQUENCE_TYPE_INFO)
    }
}

// OrtStatusPtr(* GetMapKeyType)( const OrtMapTypeInfo* map_type_info, enum ONNXTensorElementDataType* out) __attribute__((warn_unused_result))
pub const IDX_GET_MAP_KEY_TYPE: usize = 105;
pub type GetMapKeyTypeFn = unsafe extern "C" fn(
    map_type_info: *const MapTypeInfoHandle,
    out_: *mut ElementType,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_map_key_type(&self) -> GetMapKeyTypeFn {
        self.f(IDX_GET_MAP_KEY_TYPE)
    }
}

// OrtStatusPtr(* GetMapValueType)( const OrtMapTypeInfo* map_type_info, OrtTypeInfo** type_info) __attribute__((warn_unused_result))
pub const IDX_GET_MAP_VALUE_TYPE: usize = 106;
pub type GetMapValueTypeFn = unsafe extern "C" fn(
    map_type_info: *const MapTypeInfoHandle,
    type_info: *mut *mut TypeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_map_value_type(&self) -> GetMapValueTypeFn {
        self.f(IDX_GET_MAP_VALUE_TYPE)
    }
}

// OrtStatusPtr(* GetSequenceElementType)( const OrtSequenceTypeInfo* sequence_type_info, OrtTypeInfo** type_info) __attribute__((warn_unused_result))
pub const IDX_GET_SEQUENCE_ELEMENT_TYPE: usize = 107;
pub type GetSequenceElementTypeFn = unsafe extern "C" fn(
    sequence_type_info: *const SequenceTypeInfoHandle,
    type_info: *mut *mut TypeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_sequence_element_type(&self) -> GetSequenceElementTypeFn {
        self.f(IDX_GET_SEQUENCE_ELEMENT_TYPE)
    }
}

// void( * ReleaseMapTypeInfo)( OrtMapTypeInfo * input)
pub const IDX_RELEASE_MAP_TYPE_INFO: usize = 108;
pub type ReleaseMapTypeInfoFn = unsafe extern "C" fn(input: *mut MapTypeInfoHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_map_type_info(&self) -> ReleaseMapTypeInfoFn {
        self.f(IDX_RELEASE_MAP_TYPE_INFO)
    }
}

// void( * ReleaseSequenceTypeInfo)( OrtSequenceTypeInfo * input)
pub const IDX_RELEASE_SEQUENCE_TYPE_INFO: usize = 109;
pub type ReleaseSequenceTypeInfoFn = unsafe extern "C" fn(input: *mut SequenceTypeInfoHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_sequence_type_info(&self) -> ReleaseSequenceTypeInfoFn {
        self.f(IDX_RELEASE_SEQUENCE_TYPE_INFO)
    }
}

// OrtStatusPtr(* SessionEndProfiling)( OrtSession* session, OrtAllocator* allocator, char** out) __attribute__((warn_unused_result))
pub const IDX_SESSION_END_PROFILING: usize = 110;
pub type SessionEndProfilingFn = unsafe extern "C" fn(
    session: *mut SessionHandle,
    allocator: *mut AllocatorHandle,
    out_: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_end_profiling(&self) -> SessionEndProfilingFn {
        self.f(IDX_SESSION_END_PROFILING)
    }
}

// OrtStatusPtr(* SessionGetModelMetadata)( const OrtSession* session, OrtModelMetadata** out) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_MODEL_METADATA: usize = 111;
pub type SessionGetModelMetadataFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    out_: *mut *mut ModelMetadataHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_model_metadata(&self) -> SessionGetModelMetadataFn {
        self.f(IDX_SESSION_GET_MODEL_METADATA)
    }
}

// OrtStatusPtr(* ModelMetadataGetProducerName)( const OrtModelMetadata* model_metadata, OrtAllocator* allocator, char** value) __attribute__((warn_unused_result))
pub const IDX_MODEL_METADATA_GET_PRODUCER_NAME: usize = 112;
pub type ModelMetadataGetProducerNameFn = unsafe extern "C" fn(
    model_metadata: *const ModelMetadataHandle,
    allocator: *mut AllocatorHandle,
    value: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn model_metadata_get_producer_name(&self) -> ModelMetadataGetProducerNameFn {
        self.f(IDX_MODEL_METADATA_GET_PRODUCER_NAME)
    }
}

// OrtStatusPtr(* ModelMetadataGetGraphName)( const OrtModelMetadata* model_metadata, OrtAllocator* allocator, char** value) __attribute__((warn_unused_result))
pub const IDX_MODEL_METADATA_GET_GRAPH_NAME: usize = 113;
pub type ModelMetadataGetGraphNameFn = unsafe extern "C" fn(
    model_metadata: *const ModelMetadataHandle,
    allocator: *mut AllocatorHandle,
    value: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn model_metadata_get_graph_name(&self) -> ModelMetadataGetGraphNameFn {
        self.f(IDX_MODEL_METADATA_GET_GRAPH_NAME)
    }
}

// OrtStatusPtr(* ModelMetadataGetDomain)( const OrtModelMetadata* model_metadata, OrtAllocator* allocator, char** value) __attribute__((warn_unused_result))
pub const IDX_MODEL_METADATA_GET_DOMAIN: usize = 114;
pub type ModelMetadataGetDomainFn = unsafe extern "C" fn(
    model_metadata: *const ModelMetadataHandle,
    allocator: *mut AllocatorHandle,
    value: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn model_metadata_get_domain(&self) -> ModelMetadataGetDomainFn {
        self.f(IDX_MODEL_METADATA_GET_DOMAIN)
    }
}

// OrtStatusPtr(* ModelMetadataGetDescription)( const OrtModelMetadata* model_metadata, OrtAllocator* allocator, char** value) __attribute__((warn_unused_result))
pub const IDX_MODEL_METADATA_GET_DESCRIPTION: usize = 115;
pub type ModelMetadataGetDescriptionFn = unsafe extern "C" fn(
    model_metadata: *const ModelMetadataHandle,
    allocator: *mut AllocatorHandle,
    value: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn model_metadata_get_description(&self) -> ModelMetadataGetDescriptionFn {
        self.f(IDX_MODEL_METADATA_GET_DESCRIPTION)
    }
}

// OrtStatusPtr(* ModelMetadataLookupCustomMetadataMap)( const OrtModelMetadata* model_metadata, OrtAllocator* allocator, const char* key, char** value) __attribute__((warn_unused_result))
pub const IDX_MODEL_METADATA_LOOKUP_CUSTOM_METADATA_MAP: usize = 116;
pub type ModelMetadataLookupCustomMetadataMapFn = unsafe extern "C" fn(
    model_metadata: *const ModelMetadataHandle,
    allocator: *mut AllocatorHandle,
    key: *const core::ffi::c_char,
    value: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn model_metadata_lookup_custom_metadata_map(
        &self,
    ) -> ModelMetadataLookupCustomMetadataMapFn {
        self.f(IDX_MODEL_METADATA_LOOKUP_CUSTOM_METADATA_MAP)
    }
}

// OrtStatusPtr(* ModelMetadataGetVersion)( const OrtModelMetadata* model_metadata, int64_t* value) __attribute__((warn_unused_result))
pub const IDX_MODEL_METADATA_GET_VERSION: usize = 117;
pub type ModelMetadataGetVersionFn =
    unsafe extern "C" fn(model_metadata: *const ModelMetadataHandle, value: *mut i64) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn model_metadata_get_version(&self) -> ModelMetadataGetVersionFn {
        self.f(IDX_MODEL_METADATA_GET_VERSION)
    }
}

// void( * ReleaseModelMetadata)( OrtModelMetadata * input)
pub const IDX_RELEASE_MODEL_METADATA: usize = 118;
pub type ReleaseModelMetadataFn = unsafe extern "C" fn(input: *mut ModelMetadataHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_model_metadata(&self) -> ReleaseModelMetadataFn {
        self.f(IDX_RELEASE_MODEL_METADATA)
    }
}

// OrtStatusPtr(* CreateEnvWithGlobalThreadPools)(OrtLoggingLevel log_severity_level, const char* logid, const OrtThreadingOptions* tp_options, OrtEnv** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_ENV_WITH_GLOBAL_THREAD_POOLS: usize = 119;
pub type CreateEnvWithGlobalThreadPoolsFn = unsafe extern "C" fn(
    log_severity_level: LoggingLevel,
    logid: *const core::ffi::c_char,
    tp_options: *const ThreadingOptionsHandle,
    out_: *mut *mut EnvHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_env_with_global_thread_pools(&self) -> CreateEnvWithGlobalThreadPoolsFn {
        self.f(IDX_CREATE_ENV_WITH_GLOBAL_THREAD_POOLS)
    }
}

// OrtStatusPtr(* DisablePerSessionThreads)( OrtSessionOptions* options) __attribute__((warn_unused_result))
pub const IDX_DISABLE_PER_SESSION_THREADS: usize = 120;
pub type DisablePerSessionThreadsFn =
    unsafe extern "C" fn(options: *mut SessionOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn disable_per_session_threads(&self) -> DisablePerSessionThreadsFn {
        self.f(IDX_DISABLE_PER_SESSION_THREADS)
    }
}

// OrtStatusPtr(* CreateThreadingOptions)( OrtThreadingOptions** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_THREADING_OPTIONS: usize = 121;
pub type CreateThreadingOptionsFn =
    unsafe extern "C" fn(out_: *mut *mut ThreadingOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_threading_options(&self) -> CreateThreadingOptionsFn {
        self.f(IDX_CREATE_THREADING_OPTIONS)
    }
}

// void( * ReleaseThreadingOptions)( OrtThreadingOptions * input)
pub const IDX_RELEASE_THREADING_OPTIONS: usize = 122;
pub type ReleaseThreadingOptionsFn = unsafe extern "C" fn(input: *mut ThreadingOptionsHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_threading_options(&self) -> ReleaseThreadingOptionsFn {
        self.f(IDX_RELEASE_THREADING_OPTIONS)
    }
}

// OrtStatusPtr(* ModelMetadataGetCustomMetadataMapKeys)( const OrtModelMetadata* model_metadata, OrtAllocator* allocator, char*** keys, int64_t* num_keys) __attribute__((warn_unused_result))
pub const IDX_MODEL_METADATA_GET_CUSTOM_METADATA_MAP_KEYS: usize = 123;
pub type ModelMetadataGetCustomMetadataMapKeysFn = unsafe extern "C" fn(
    model_metadata: *const ModelMetadataHandle,
    allocator: *mut AllocatorHandle,
    keys: *mut *mut *mut core::ffi::c_char,
    num_keys: *mut i64,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn model_metadata_get_custom_metadata_map_keys(
        &self,
    ) -> ModelMetadataGetCustomMetadataMapKeysFn {
        self.f(IDX_MODEL_METADATA_GET_CUSTOM_METADATA_MAP_KEYS)
    }
}

// OrtStatusPtr(* AddFreeDimensionOverrideByName)( OrtSessionOptions* options, const char* dim_name, int64_t dim_value) __attribute__((warn_unused_result))
pub const IDX_ADD_FREE_DIMENSION_OVERRIDE_BY_NAME: usize = 124;
pub type AddFreeDimensionOverrideByNameFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    dim_name: *const core::ffi::c_char,
    dim_value: i64,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn add_free_dimension_override_by_name(&self) -> AddFreeDimensionOverrideByNameFn {
        self.f(IDX_ADD_FREE_DIMENSION_OVERRIDE_BY_NAME)
    }
}

// OrtStatusPtr(* GetAvailableProviders)( char*** out_ptr, int* provider_length) __attribute__((warn_unused_result))
pub const IDX_GET_AVAILABLE_PROVIDERS: usize = 125;
pub type GetAvailableProvidersFn = unsafe extern "C" fn(
    out_ptr: *mut *mut *mut core::ffi::c_char,
    provider_length: *mut core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_available_providers(&self) -> GetAvailableProvidersFn {
        self.f(IDX_GET_AVAILABLE_PROVIDERS)
    }
}

// OrtStatusPtr(* ReleaseAvailableProviders)( char** ptr, int providers_length) __attribute__((warn_unused_result))
pub const IDX_RELEASE_AVAILABLE_PROVIDERS: usize = 126;
pub type ReleaseAvailableProvidersFn = unsafe extern "C" fn(
    ptr: *mut *mut core::ffi::c_char,
    providers_length: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn release_available_providers(&self) -> ReleaseAvailableProvidersFn {
        self.f(IDX_RELEASE_AVAILABLE_PROVIDERS)
    }
}

// OrtStatusPtr(* GetStringTensorElementLength)( const OrtValue* value, size_t index, size_t* out) __attribute__((warn_unused_result))
pub const IDX_GET_STRING_TENSOR_ELEMENT_LENGTH: usize = 127;
pub type GetStringTensorElementLengthFn =
    unsafe extern "C" fn(value: *const ValueHandle, index: usize, out_: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_string_tensor_element_length(&self) -> GetStringTensorElementLengthFn {
        self.f(IDX_GET_STRING_TENSOR_ELEMENT_LENGTH)
    }
}

// OrtStatusPtr(* GetStringTensorElement)( const OrtValue* value, size_t s_len, size_t index, void* s) __attribute__((warn_unused_result))
pub const IDX_GET_STRING_TENSOR_ELEMENT: usize = 128;
pub type GetStringTensorElementFn = unsafe extern "C" fn(
    value: *const ValueHandle,
    s_len: usize,
    index: usize,
    s: *mut core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_string_tensor_element(&self) -> GetStringTensorElementFn {
        self.f(IDX_GET_STRING_TENSOR_ELEMENT)
    }
}

// OrtStatusPtr(* FillStringTensorElement)( OrtValue* value, const char* s, size_t index) __attribute__((warn_unused_result))
pub const IDX_FILL_STRING_TENSOR_ELEMENT: usize = 129;
pub type FillStringTensorElementFn = unsafe extern "C" fn(
    value: *mut ValueHandle,
    s: *const core::ffi::c_char,
    index: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn fill_string_tensor_element(&self) -> FillStringTensorElementFn {
        self.f(IDX_FILL_STRING_TENSOR_ELEMENT)
    }
}

// OrtStatusPtr(* AddSessionConfigEntry)( OrtSessionOptions* options, const char* config_key, const char* config_value) __attribute__((warn_unused_result))
pub const IDX_ADD_SESSION_CONFIG_ENTRY: usize = 130;
pub type AddSessionConfigEntryFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    config_key: *const core::ffi::c_char,
    config_value: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn add_session_config_entry(&self) -> AddSessionConfigEntryFn {
        self.f(IDX_ADD_SESSION_CONFIG_ENTRY)
    }
}

// OrtStatusPtr(* CreateAllocator)( const OrtSession* session, const OrtMemoryInfo* mem_info, OrtAllocator** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_ALLOCATOR: usize = 131;
pub type CreateAllocatorFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    mem_info: *const MemoryInfoHandle,
    out_: *mut *mut AllocatorHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_allocator(&self) -> CreateAllocatorFn {
        self.f(IDX_CREATE_ALLOCATOR)
    }
}

// void( * ReleaseAllocator)( OrtAllocator * input)
pub const IDX_RELEASE_ALLOCATOR: usize = 132;
pub type ReleaseAllocatorFn = unsafe extern "C" fn(input: *mut AllocatorHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_allocator(&self) -> ReleaseAllocatorFn {
        self.f(IDX_RELEASE_ALLOCATOR)
    }
}

// OrtStatusPtr(* RunWithBinding)( OrtSession* session, const OrtRunOptions* run_options, const OrtIoBinding* binding_ptr) __attribute__((warn_unused_result))
pub const IDX_RUN_WITH_BINDING: usize = 133;
pub type RunWithBindingFn = unsafe extern "C" fn(
    session: *mut SessionHandle,
    run_options: *const RunOptionsHandle,
    binding_ptr: *const IoBindingHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_with_binding(&self) -> RunWithBindingFn {
        self.f(IDX_RUN_WITH_BINDING)
    }
}

// OrtStatusPtr(* CreateIoBinding)( OrtSession* session, OrtIoBinding** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_IO_BINDING: usize = 134;
pub type CreateIoBindingFn =
    unsafe extern "C" fn(session: *mut SessionHandle, out_: *mut *mut IoBindingHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_io_binding(&self) -> CreateIoBindingFn {
        self.f(IDX_CREATE_IO_BINDING)
    }
}

// void( * ReleaseIoBinding)( OrtIoBinding * input)
pub const IDX_RELEASE_IO_BINDING: usize = 135;
pub type ReleaseIoBindingFn = unsafe extern "C" fn(input: *mut IoBindingHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_io_binding(&self) -> ReleaseIoBindingFn {
        self.f(IDX_RELEASE_IO_BINDING)
    }
}

// OrtStatusPtr(* BindInput)( OrtIoBinding* binding_ptr, const char* name, const OrtValue* val_ptr) __attribute__((warn_unused_result))
pub const IDX_BIND_INPUT: usize = 136;
pub type BindInputFn = unsafe extern "C" fn(
    binding_ptr: *mut IoBindingHandle,
    name: *const core::ffi::c_char,
    val_ptr: *const ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn bind_input(&self) -> BindInputFn {
        self.f(IDX_BIND_INPUT)
    }
}

// OrtStatusPtr(* BindOutput)( OrtIoBinding* binding_ptr, const char* name, const OrtValue* val_ptr) __attribute__((warn_unused_result))
pub const IDX_BIND_OUTPUT: usize = 137;
pub type BindOutputFn = unsafe extern "C" fn(
    binding_ptr: *mut IoBindingHandle,
    name: *const core::ffi::c_char,
    val_ptr: *const ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn bind_output(&self) -> BindOutputFn {
        self.f(IDX_BIND_OUTPUT)
    }
}

// OrtStatusPtr(* BindOutputToDevice)( OrtIoBinding* binding_ptr, const char* name, const OrtMemoryInfo* mem_info_ptr) __attribute__((warn_unused_result))
pub const IDX_BIND_OUTPUT_TO_DEVICE: usize = 138;
pub type BindOutputToDeviceFn = unsafe extern "C" fn(
    binding_ptr: *mut IoBindingHandle,
    name: *const core::ffi::c_char,
    mem_info_ptr: *const MemoryInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn bind_output_to_device(&self) -> BindOutputToDeviceFn {
        self.f(IDX_BIND_OUTPUT_TO_DEVICE)
    }
}

// OrtStatusPtr(* GetBoundOutputNames)( const OrtIoBinding* binding_ptr, OrtAllocator* allocator, char** buffer, size_t** lengths, size_t* count) __attribute__((warn_unused_result))
pub const IDX_GET_BOUND_OUTPUT_NAMES: usize = 139;
pub type GetBoundOutputNamesFn = unsafe extern "C" fn(
    binding_ptr: *const IoBindingHandle,
    allocator: *mut AllocatorHandle,
    buffer: *mut *mut core::ffi::c_char,
    lengths: *mut *mut usize,
    count: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_bound_output_names(&self) -> GetBoundOutputNamesFn {
        self.f(IDX_GET_BOUND_OUTPUT_NAMES)
    }
}

// OrtStatusPtr(* GetBoundOutputValues)( const OrtIoBinding* binding_ptr, OrtAllocator* allocator, OrtValue*** output, size_t* output_count) __attribute__((warn_unused_result))
pub const IDX_GET_BOUND_OUTPUT_VALUES: usize = 140;
pub type GetBoundOutputValuesFn = unsafe extern "C" fn(
    binding_ptr: *const IoBindingHandle,
    allocator: *mut AllocatorHandle,
    output: *mut *mut *mut ValueHandle,
    output_count: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_bound_output_values(&self) -> GetBoundOutputValuesFn {
        self.f(IDX_GET_BOUND_OUTPUT_VALUES)
    }
}

// void(* ClearBoundInputs)( OrtIoBinding* binding_ptr) __attribute__((nonnull))
pub const IDX_CLEAR_BOUND_INPUTS: usize = 141;
pub type ClearBoundInputsFn = unsafe extern "C" fn(binding_ptr: *mut IoBindingHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn clear_bound_inputs(&self) -> ClearBoundInputsFn {
        self.f(IDX_CLEAR_BOUND_INPUTS)
    }
}

// void(* ClearBoundOutputs)( OrtIoBinding* binding_ptr) __attribute__((nonnull))
pub const IDX_CLEAR_BOUND_OUTPUTS: usize = 142;
pub type ClearBoundOutputsFn = unsafe extern "C" fn(binding_ptr: *mut IoBindingHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn clear_bound_outputs(&self) -> ClearBoundOutputsFn {
        self.f(IDX_CLEAR_BOUND_OUTPUTS)
    }
}

// OrtStatusPtr(* TensorAt)( OrtValue* value, const int64_t* location_values, size_t location_values_count, void** out) __attribute__((warn_unused_result))
pub const IDX_TENSOR_AT: usize = 143;
pub type TensorAtFn = unsafe extern "C" fn(
    value: *mut ValueHandle,
    location_values: *const i64,
    location_values_count: usize,
    out_: *mut *mut core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn tensor_at(&self) -> TensorAtFn {
        self.f(IDX_TENSOR_AT)
    }
}

// OrtStatusPtr(* CreateAndRegisterAllocator)( OrtEnv* env, const OrtMemoryInfo* mem_info, const OrtArenaCfg* arena_cfg) __attribute__((warn_unused_result))
pub const IDX_CREATE_AND_REGISTER_ALLOCATOR: usize = 144;
pub type CreateAndRegisterAllocatorFn = unsafe extern "C" fn(
    env: *mut EnvHandle,
    mem_info: *const MemoryInfoHandle,
    arena_cfg: *const ArenaCfgHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_and_register_allocator(&self) -> CreateAndRegisterAllocatorFn {
        self.f(IDX_CREATE_AND_REGISTER_ALLOCATOR)
    }
}

// OrtStatusPtr(* SetLanguageProjection)( const OrtEnv* ort_env, OrtLanguageProjection projection) __attribute__((warn_unused_result))
pub const IDX_SET_LANGUAGE_PROJECTION: usize = 145;
pub type SetLanguageProjectionFn =
    unsafe extern "C" fn(ort_env: *const EnvHandle, projection: i32) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_language_projection(&self) -> SetLanguageProjectionFn {
        self.f(IDX_SET_LANGUAGE_PROJECTION)
    }
}

// OrtStatusPtr(* SessionGetProfilingStartTimeNs)( const OrtSession* session, uint64_t* out) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_PROFILING_START_TIME_NS: usize = 146;
pub type SessionGetProfilingStartTimeNsFn =
    unsafe extern "C" fn(session: *const SessionHandle, out_: *mut u64) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_profiling_start_time_ns(&self) -> SessionGetProfilingStartTimeNsFn {
        self.f(IDX_SESSION_GET_PROFILING_START_TIME_NS)
    }
}

// OrtStatusPtr(* SetGlobalIntraOpNumThreads)( OrtThreadingOptions* tp_options, int intra_op_num_threads) __attribute__((warn_unused_result))
pub const IDX_SET_GLOBAL_INTRA_OP_NUM_THREADS: usize = 147;
pub type SetGlobalIntraOpNumThreadsFn = unsafe extern "C" fn(
    tp_options: *mut ThreadingOptionsHandle,
    intra_op_num_threads: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_global_intra_op_num_threads(&self) -> SetGlobalIntraOpNumThreadsFn {
        self.f(IDX_SET_GLOBAL_INTRA_OP_NUM_THREADS)
    }
}

// OrtStatusPtr(* SetGlobalInterOpNumThreads)( OrtThreadingOptions* tp_options, int inter_op_num_threads) __attribute__((warn_unused_result))
pub const IDX_SET_GLOBAL_INTER_OP_NUM_THREADS: usize = 148;
pub type SetGlobalInterOpNumThreadsFn = unsafe extern "C" fn(
    tp_options: *mut ThreadingOptionsHandle,
    inter_op_num_threads: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_global_inter_op_num_threads(&self) -> SetGlobalInterOpNumThreadsFn {
        self.f(IDX_SET_GLOBAL_INTER_OP_NUM_THREADS)
    }
}

// OrtStatusPtr(* SetGlobalSpinControl)( OrtThreadingOptions* tp_options, int allow_spinning) __attribute__((warn_unused_result))
pub const IDX_SET_GLOBAL_SPIN_CONTROL: usize = 149;
pub type SetGlobalSpinControlFn = unsafe extern "C" fn(
    tp_options: *mut ThreadingOptionsHandle,
    allow_spinning: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_global_spin_control(&self) -> SetGlobalSpinControlFn {
        self.f(IDX_SET_GLOBAL_SPIN_CONTROL)
    }
}

// OrtStatusPtr(* AddInitializer)( OrtSessionOptions* options, const char* name, const OrtValue* val) __attribute__((warn_unused_result))
pub const IDX_ADD_INITIALIZER: usize = 150;
pub type AddInitializerFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    name: *const core::ffi::c_char,
    val: *const ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn add_initializer(&self) -> AddInitializerFn {
        self.f(IDX_ADD_INITIALIZER)
    }
}

// OrtStatusPtr(* CreateEnvWithCustomLoggerAndGlobalThreadPools)(OrtLoggingFunction logging_function, void* logger_param, OrtLoggingLevel log_severity_level, const char* logid, const struct OrtThreadingOptions* tp_options, OrtEnv** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_ENV_WITH_CUSTOM_LOGGER_AND_GLOBAL_THREAD_POOLS: usize = 151;
pub type CreateEnvWithCustomLoggerAndGlobalThreadPoolsFn = unsafe extern "C" fn(
    logging_function: LoggingFunction,
    logger_param: *mut core::ffi::c_void,
    log_severity_level: LoggingLevel,
    logid: *const core::ffi::c_char,
    tp_options: *const ThreadingOptionsHandle,
    out_: *mut *mut EnvHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_env_with_custom_logger_and_global_thread_pools(
        &self,
    ) -> CreateEnvWithCustomLoggerAndGlobalThreadPoolsFn {
        self.f(IDX_CREATE_ENV_WITH_CUSTOM_LOGGER_AND_GLOBAL_THREAD_POOLS)
    }
}

// OrtStatusPtr(* SetGlobalDenormalAsZero)( OrtThreadingOptions* tp_options) __attribute__((warn_unused_result))
pub const IDX_SET_GLOBAL_DENORMAL_AS_ZERO: usize = 155;
pub type SetGlobalDenormalAsZeroFn =
    unsafe extern "C" fn(tp_options: *mut ThreadingOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_global_denormal_as_zero(&self) -> SetGlobalDenormalAsZeroFn {
        self.f(IDX_SET_GLOBAL_DENORMAL_AS_ZERO)
    }
}

// OrtStatusPtr(* CreateArenaCfg)( size_t max_mem, int arena_extend_strategy, int initial_chunk_size_bytes, int max_dead_bytes_per_chunk, OrtArenaCfg** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_ARENA_CFG: usize = 156;
pub type CreateArenaCfgFn = unsafe extern "C" fn(
    max_mem: usize,
    arena_extend_strategy: core::ffi::c_int,
    initial_chunk_size_bytes: core::ffi::c_int,
    max_dead_bytes_per_chunk: core::ffi::c_int,
    out_: *mut *mut ArenaCfgHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_arena_cfg(&self) -> CreateArenaCfgFn {
        self.f(IDX_CREATE_ARENA_CFG)
    }
}

// void( * ReleaseArenaCfg)( OrtArenaCfg * input)
pub const IDX_RELEASE_ARENA_CFG: usize = 157;
pub type ReleaseArenaCfgFn = unsafe extern "C" fn(input: *mut ArenaCfgHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_arena_cfg(&self) -> ReleaseArenaCfgFn {
        self.f(IDX_RELEASE_ARENA_CFG)
    }
}

// OrtStatusPtr(* ModelMetadataGetGraphDescription)( const OrtModelMetadata* model_metadata, OrtAllocator* allocator, char** value) __attribute__((warn_unused_result))
pub const IDX_MODEL_METADATA_GET_GRAPH_DESCRIPTION: usize = 158;
pub type ModelMetadataGetGraphDescriptionFn = unsafe extern "C" fn(
    model_metadata: *const ModelMetadataHandle,
    allocator: *mut AllocatorHandle,
    value: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn model_metadata_get_graph_description(
        &self,
    ) -> ModelMetadataGetGraphDescriptionFn {
        self.f(IDX_MODEL_METADATA_GET_GRAPH_DESCRIPTION)
    }
}

// OrtStatusPtr(* SetCurrentGpuDeviceId)( int device_id) __attribute__((warn_unused_result))
pub const IDX_SET_CURRENT_GPU_DEVICE_ID: usize = 160;
pub type SetCurrentGpuDeviceIdFn = unsafe extern "C" fn(device_id: core::ffi::c_int) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_current_gpu_device_id(&self) -> SetCurrentGpuDeviceIdFn {
        self.f(IDX_SET_CURRENT_GPU_DEVICE_ID)
    }
}

// OrtStatusPtr(* GetCurrentGpuDeviceId)( int* device_id) __attribute__((warn_unused_result))
pub const IDX_GET_CURRENT_GPU_DEVICE_ID: usize = 161;
pub type GetCurrentGpuDeviceIdFn =
    unsafe extern "C" fn(device_id: *mut core::ffi::c_int) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_current_gpu_device_id(&self) -> GetCurrentGpuDeviceIdFn {
        self.f(IDX_GET_CURRENT_GPU_DEVICE_ID)
    }
}

// OrtStatusPtr(* CreateArenaCfgV2)( const char* const* arena_config_keys, const size_t* arena_config_values, size_t num_keys, OrtArenaCfg** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_ARENA_CFG_V2: usize = 164;
pub type CreateArenaCfgV2Fn = unsafe extern "C" fn(
    arena_config_keys: *const *const core::ffi::c_char,
    arena_config_values: *const usize,
    num_keys: usize,
    out_: *mut *mut ArenaCfgHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_arena_cfg_v2(&self) -> CreateArenaCfgV2Fn {
        self.f(IDX_CREATE_ARENA_CFG_V2)
    }
}

// OrtStatusPtr(* AddRunConfigEntry)( OrtRunOptions* options, const char* config_key, const char* config_value) __attribute__((warn_unused_result))
pub const IDX_ADD_RUN_CONFIG_ENTRY: usize = 165;
pub type AddRunConfigEntryFn = unsafe extern "C" fn(
    options: *mut RunOptionsHandle,
    config_key: *const core::ffi::c_char,
    config_value: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn add_run_config_entry(&self) -> AddRunConfigEntryFn {
        self.f(IDX_ADD_RUN_CONFIG_ENTRY)
    }
}

// OrtStatusPtr(* CreatePrepackedWeightsContainer)( OrtPrepackedWeightsContainer** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_PREPACKED_WEIGHTS_CONTAINER: usize = 166;
pub type CreatePrepackedWeightsContainerFn =
    unsafe extern "C" fn(out_: *mut *mut PrepackedWeightsContainerHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_prepacked_weights_container(&self) -> CreatePrepackedWeightsContainerFn {
        self.f(IDX_CREATE_PREPACKED_WEIGHTS_CONTAINER)
    }
}

// void( * ReleasePrepackedWeightsContainer)( OrtPrepackedWeightsContainer * input)
pub const IDX_RELEASE_PREPACKED_WEIGHTS_CONTAINER: usize = 167;
pub type ReleasePrepackedWeightsContainerFn =
    unsafe extern "C" fn(input: *mut PrepackedWeightsContainerHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_prepacked_weights_container(&self) -> ReleasePrepackedWeightsContainerFn {
        self.f(IDX_RELEASE_PREPACKED_WEIGHTS_CONTAINER)
    }
}

// OrtStatusPtr(* CreateSessionWithPrepackedWeightsContainer)( const OrtEnv* env, const char* model_path, const OrtSessionOptions* options, OrtPrepackedWeightsContainer* prepacked_weights_container, OrtSession** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_SESSION_WITH_PREPACKED_WEIGHTS_CONTAINER: usize = 168;
pub type CreateSessionWithPrepackedWeightsContainerFn = unsafe extern "C" fn(
    env: *const EnvHandle,
    model_path: *const core::ffi::c_char,
    options: *const SessionOptionsHandle,
    prepacked_weights_container: *mut PrepackedWeightsContainerHandle,
    out_: *mut *mut SessionHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_session_with_prepacked_weights_container(
        &self,
    ) -> CreateSessionWithPrepackedWeightsContainerFn {
        self.f(IDX_CREATE_SESSION_WITH_PREPACKED_WEIGHTS_CONTAINER)
    }
}

// OrtStatusPtr(* CreateSessionFromArrayWithPrepackedWeightsContainer)( const OrtEnv* env, const void* model_data, size_t model_data_length, const OrtSessionOptions* options, OrtPrepackedWeightsContainer* prepacked_weights_container, OrtSession** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_SESSION_FROM_ARRAY_WITH_PREPACKED_WEIGHTS_CONTAINER: usize = 169;
pub type CreateSessionFromArrayWithPrepackedWeightsContainerFn = unsafe extern "C" fn(
    env: *const EnvHandle,
    model_data: *const core::ffi::c_void,
    model_data_length: usize,
    options: *const SessionOptionsHandle,
    prepacked_weights_container: *mut PrepackedWeightsContainerHandle,
    out_: *mut *mut SessionHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_session_from_array_with_prepacked_weights_container(
        &self,
    ) -> CreateSessionFromArrayWithPrepackedWeightsContainerFn {
        self.f(IDX_CREATE_SESSION_FROM_ARRAY_WITH_PREPACKED_WEIGHTS_CONTAINER)
    }
}

// OrtStatusPtr(* EnableOrtCustomOps)( OrtSessionOptions* options) __attribute__((warn_unused_result))
pub const IDX_ENABLE_ORT_CUSTOM_OPS: usize = 175;
pub type EnableOrtCustomOpsFn =
    unsafe extern "C" fn(options: *mut SessionOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn enable_ort_custom_ops(&self) -> EnableOrtCustomOpsFn {
        self.f(IDX_ENABLE_ORT_CUSTOM_OPS)
    }
}

// OrtStatusPtr(* RegisterAllocator)( OrtEnv* env, OrtAllocator* allocator) __attribute__((warn_unused_result))
pub const IDX_REGISTER_ALLOCATOR: usize = 176;
pub type RegisterAllocatorFn =
    unsafe extern "C" fn(env: *mut EnvHandle, allocator: *mut AllocatorHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn register_allocator(&self) -> RegisterAllocatorFn {
        self.f(IDX_REGISTER_ALLOCATOR)
    }
}

// OrtStatusPtr(* UnregisterAllocator)( OrtEnv* env, const OrtMemoryInfo* mem_info) __attribute__((warn_unused_result))
pub const IDX_UNREGISTER_ALLOCATOR: usize = 177;
pub type UnregisterAllocatorFn =
    unsafe extern "C" fn(env: *mut EnvHandle, mem_info: *const MemoryInfoHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn unregister_allocator(&self) -> UnregisterAllocatorFn {
        self.f(IDX_UNREGISTER_ALLOCATOR)
    }
}

// OrtStatusPtr(* IsSparseTensor)( const OrtValue* value, int* out) __attribute__((warn_unused_result))
pub const IDX_IS_SPARSE_TENSOR: usize = 178;
pub type IsSparseTensorFn =
    unsafe extern "C" fn(value: *const ValueHandle, out_: *mut core::ffi::c_int) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn is_sparse_tensor(&self) -> IsSparseTensorFn {
        self.f(IDX_IS_SPARSE_TENSOR)
    }
}

// OrtStatusPtr(* CreateSparseTensorAsOrtValue)( OrtAllocator* allocator, const int64_t* dense_shape, size_t dense_shape_len, ONNXTensorElementDataType type, OrtValue** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_SPARSE_TENSOR_AS_ORT_VALUE: usize = 179;
pub type CreateSparseTensorAsOrtValueFn = unsafe extern "C" fn(
    allocator: *mut AllocatorHandle,
    dense_shape: *const i64,
    dense_shape_len: usize,
    type_: ElementType,
    out_: *mut *mut ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_sparse_tensor_as_ort_value(&self) -> CreateSparseTensorAsOrtValueFn {
        self.f(IDX_CREATE_SPARSE_TENSOR_AS_ORT_VALUE)
    }
}

// OrtStatusPtr(* FillSparseTensorCoo)( OrtValue* ort_value, const OrtMemoryInfo* data_mem_info, const int64_t* values_shape, size_t values_shape_len, const void* values, const int64_t* indices_data, size_t indices_num) __attribute__((warn_unused_result))
pub const IDX_FILL_SPARSE_TENSOR_COO: usize = 180;
pub type FillSparseTensorCooFn = unsafe extern "C" fn(
    ort_value: *mut ValueHandle,
    data_mem_info: *const MemoryInfoHandle,
    values_shape: *const i64,
    values_shape_len: usize,
    values: *const core::ffi::c_void,
    indices_data: *const i64,
    indices_num: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn fill_sparse_tensor_coo(&self) -> FillSparseTensorCooFn {
        self.f(IDX_FILL_SPARSE_TENSOR_COO)
    }
}

// OrtStatusPtr(* FillSparseTensorCsr)( OrtValue* ort_value, const OrtMemoryInfo* data_mem_info, const int64_t* values_shape, size_t values_shape_len, const void* values, const int64_t* inner_indices_data, size_t inner_indices_num, const int64_t* outer_indices_data, size_t outer_indices_num) __attribute__((warn_unused_result))
pub const IDX_FILL_SPARSE_TENSOR_CSR: usize = 181;
pub type FillSparseTensorCsrFn = unsafe extern "C" fn(
    ort_value: *mut ValueHandle,
    data_mem_info: *const MemoryInfoHandle,
    values_shape: *const i64,
    values_shape_len: usize,
    values: *const core::ffi::c_void,
    inner_indices_data: *const i64,
    inner_indices_num: usize,
    outer_indices_data: *const i64,
    outer_indices_num: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn fill_sparse_tensor_csr(&self) -> FillSparseTensorCsrFn {
        self.f(IDX_FILL_SPARSE_TENSOR_CSR)
    }
}

// OrtStatusPtr(* FillSparseTensorBlockSparse)( OrtValue* ort_value, const OrtMemoryInfo* data_mem_info, const int64_t* values_shape, size_t values_shape_len, const void* values, const int64_t* indices_shape_data, size_t indices_shape_len, const int32_t* indices_data) __attribute__((warn_unused_result))
pub const IDX_FILL_SPARSE_TENSOR_BLOCK_SPARSE: usize = 182;
pub type FillSparseTensorBlockSparseFn = unsafe extern "C" fn(
    ort_value: *mut ValueHandle,
    data_mem_info: *const MemoryInfoHandle,
    values_shape: *const i64,
    values_shape_len: usize,
    values: *const core::ffi::c_void,
    indices_shape_data: *const i64,
    indices_shape_len: usize,
    indices_data: *const i32,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn fill_sparse_tensor_block_sparse(&self) -> FillSparseTensorBlockSparseFn {
        self.f(IDX_FILL_SPARSE_TENSOR_BLOCK_SPARSE)
    }
}

// OrtStatusPtr(* CreateSparseTensorWithValuesAsOrtValue)( const OrtMemoryInfo* info, void* p_data, const int64_t* dense_shape, size_t dense_shape_len, const int64_t* values_shape, size_t values_shape_len, ONNXTensorElementDataType type, OrtValue** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_SPARSE_TENSOR_WITH_VALUES_AS_ORT_VALUE: usize = 183;
pub type CreateSparseTensorWithValuesAsOrtValueFn = unsafe extern "C" fn(
    info: *const MemoryInfoHandle,
    p_data: *mut core::ffi::c_void,
    dense_shape: *const i64,
    dense_shape_len: usize,
    values_shape: *const i64,
    values_shape_len: usize,
    type_: ElementType,
    out_: *mut *mut ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_sparse_tensor_with_values_as_ort_value(
        &self,
    ) -> CreateSparseTensorWithValuesAsOrtValueFn {
        self.f(IDX_CREATE_SPARSE_TENSOR_WITH_VALUES_AS_ORT_VALUE)
    }
}

// OrtStatusPtr(* UseCooIndices)( OrtValue* ort_value, int64_t* indices_data, size_t indices_num) __attribute__((warn_unused_result))
pub const IDX_USE_COO_INDICES: usize = 184;
pub type UseCooIndicesFn = unsafe extern "C" fn(
    ort_value: *mut ValueHandle,
    indices_data: *mut i64,
    indices_num: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn use_coo_indices(&self) -> UseCooIndicesFn {
        self.f(IDX_USE_COO_INDICES)
    }
}

// OrtStatusPtr(* UseCsrIndices)( OrtValue* ort_value, int64_t* inner_data, size_t inner_num, int64_t* outer_data, size_t outer_num) __attribute__((warn_unused_result))
pub const IDX_USE_CSR_INDICES: usize = 185;
pub type UseCsrIndicesFn = unsafe extern "C" fn(
    ort_value: *mut ValueHandle,
    inner_data: *mut i64,
    inner_num: usize,
    outer_data: *mut i64,
    outer_num: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn use_csr_indices(&self) -> UseCsrIndicesFn {
        self.f(IDX_USE_CSR_INDICES)
    }
}

// OrtStatusPtr(* UseBlockSparseIndices)( OrtValue* ort_value, const int64_t* indices_shape, size_t indices_shape_len, int32_t* indices_data) __attribute__((warn_unused_result))
pub const IDX_USE_BLOCK_SPARSE_INDICES: usize = 186;
pub type UseBlockSparseIndicesFn = unsafe extern "C" fn(
    ort_value: *mut ValueHandle,
    indices_shape: *const i64,
    indices_shape_len: usize,
    indices_data: *mut i32,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn use_block_sparse_indices(&self) -> UseBlockSparseIndicesFn {
        self.f(IDX_USE_BLOCK_SPARSE_INDICES)
    }
}

// OrtStatusPtr(* GetSparseTensorFormat)( const OrtValue* ort_value, enum OrtSparseFormat* out) __attribute__((warn_unused_result))
pub const IDX_GET_SPARSE_TENSOR_FORMAT: usize = 187;
pub type GetSparseTensorFormatFn =
    unsafe extern "C" fn(ort_value: *const ValueHandle, out_: *mut SparseFormat) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_sparse_tensor_format(&self) -> GetSparseTensorFormatFn {
        self.f(IDX_GET_SPARSE_TENSOR_FORMAT)
    }
}

// OrtStatusPtr(* GetSparseTensorValuesTypeAndShape)( const OrtValue* ort_value, OrtTensorTypeAndShapeInfo** out) __attribute__((warn_unused_result))
pub const IDX_GET_SPARSE_TENSOR_VALUES_TYPE_AND_SHAPE: usize = 188;
pub type GetSparseTensorValuesTypeAndShapeFn = unsafe extern "C" fn(
    ort_value: *const ValueHandle,
    out_: *mut *mut TensorTypeAndShapeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_sparse_tensor_values_type_and_shape(
        &self,
    ) -> GetSparseTensorValuesTypeAndShapeFn {
        self.f(IDX_GET_SPARSE_TENSOR_VALUES_TYPE_AND_SHAPE)
    }
}

// OrtStatusPtr(* GetSparseTensorValues)( const OrtValue* ort_value, const void** out) __attribute__((warn_unused_result))
pub const IDX_GET_SPARSE_TENSOR_VALUES: usize = 189;
pub type GetSparseTensorValuesFn = unsafe extern "C" fn(
    ort_value: *const ValueHandle,
    out_: *const *const core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_sparse_tensor_values(&self) -> GetSparseTensorValuesFn {
        self.f(IDX_GET_SPARSE_TENSOR_VALUES)
    }
}

// OrtStatusPtr(* GetSparseTensorIndicesTypeShape)( const OrtValue* ort_value, enum OrtSparseIndicesFormat indices_format, OrtTensorTypeAndShapeInfo** out) __attribute__((warn_unused_result))
pub const IDX_GET_SPARSE_TENSOR_INDICES_TYPE_SHAPE: usize = 190;
pub type GetSparseTensorIndicesTypeShapeFn = unsafe extern "C" fn(
    ort_value: *const ValueHandle,
    indices_format: SparseIndicesFormat,
    out_: *mut *mut TensorTypeAndShapeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_sparse_tensor_indices_type_shape(&self) -> GetSparseTensorIndicesTypeShapeFn {
        self.f(IDX_GET_SPARSE_TENSOR_INDICES_TYPE_SHAPE)
    }
}

// OrtStatusPtr(* GetSparseTensorIndices)( const OrtValue* ort_value, enum OrtSparseIndicesFormat indices_format, size_t* num_indices, const void** indices) __attribute__((warn_unused_result))
pub const IDX_GET_SPARSE_TENSOR_INDICES: usize = 191;
pub type GetSparseTensorIndicesFn = unsafe extern "C" fn(
    ort_value: *const ValueHandle,
    indices_format: SparseIndicesFormat,
    num_indices: *mut usize,
    indices: *const *const core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_sparse_tensor_indices(&self) -> GetSparseTensorIndicesFn {
        self.f(IDX_GET_SPARSE_TENSOR_INDICES)
    }
}

// OrtStatusPtr(* HasValue)( const OrtValue* value, int* out) __attribute__((warn_unused_result))
pub const IDX_HAS_VALUE: usize = 192;
pub type HasValueFn =
    unsafe extern "C" fn(value: *const ValueHandle, out_: *mut core::ffi::c_int) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn has_value(&self) -> HasValueFn {
        self.f(IDX_HAS_VALUE)
    }
}

// OrtStatusPtr(* GetTensorMemoryInfo)( const OrtValue* value, const OrtMemoryInfo** mem_info) __attribute__((warn_unused_result))
pub const IDX_GET_TENSOR_MEMORY_INFO: usize = 194;
pub type GetTensorMemoryInfoFn = unsafe extern "C" fn(
    value: *const ValueHandle,
    mem_info: *const *const MemoryInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_tensor_memory_info(&self) -> GetTensorMemoryInfoFn {
        self.f(IDX_GET_TENSOR_MEMORY_INFO)
    }
}

// OrtStatusPtr(* GetExecutionProviderApi)( const char* provider_name, uint32_t version, const void** provider_api) __attribute__((warn_unused_result))
pub const IDX_GET_EXECUTION_PROVIDER_API: usize = 195;
pub type GetExecutionProviderApiFn = unsafe extern "C" fn(
    provider_name: *const core::ffi::c_char,
    version: u32,
    provider_api: *const *const core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_execution_provider_api(&self) -> GetExecutionProviderApiFn {
        self.f(IDX_GET_EXECUTION_PROVIDER_API)
    }
}

// OrtStatusPtr(* SessionOptionsSetCustomCreateThreadFn)( OrtSessionOptions* options, OrtCustomCreateThreadFn ort_custom_create_thread_fn) __attribute__((warn_unused_result))
pub const IDX_SESSION_OPTIONS_SET_CUSTOM_CREATE_THREAD_FN: usize = 196;
pub type SessionOptionsSetCustomCreateThreadFnFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    ort_custom_create_thread_fn: CustomCreateThreadFnHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_options_set_custom_create_thread_fn(
        &self,
    ) -> SessionOptionsSetCustomCreateThreadFnFn {
        self.f(IDX_SESSION_OPTIONS_SET_CUSTOM_CREATE_THREAD_FN)
    }
}

// OrtStatusPtr(* SessionOptionsSetCustomThreadCreationOptions)( OrtSessionOptions* options, void* ort_custom_thread_creation_options) __attribute__((warn_unused_result))
pub const IDX_SESSION_OPTIONS_SET_CUSTOM_THREAD_CREATION_OPTIONS: usize = 197;
pub type SessionOptionsSetCustomThreadCreationOptionsFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    ort_custom_thread_creation_options: *mut core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_options_set_custom_thread_creation_options(
        &self,
    ) -> SessionOptionsSetCustomThreadCreationOptionsFn {
        self.f(IDX_SESSION_OPTIONS_SET_CUSTOM_THREAD_CREATION_OPTIONS)
    }
}

// OrtStatusPtr(* SessionOptionsSetCustomJoinThreadFn)( OrtSessionOptions* options, OrtCustomJoinThreadFn ort_custom_join_thread_fn) __attribute__((warn_unused_result))
pub const IDX_SESSION_OPTIONS_SET_CUSTOM_JOIN_THREAD_FN: usize = 198;
pub type SessionOptionsSetCustomJoinThreadFnFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    ort_custom_join_thread_fn: CustomJoinThreadFnHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_options_set_custom_join_thread_fn(
        &self,
    ) -> SessionOptionsSetCustomJoinThreadFnFn {
        self.f(IDX_SESSION_OPTIONS_SET_CUSTOM_JOIN_THREAD_FN)
    }
}

// OrtStatusPtr(* SetGlobalCustomCreateThreadFn)( OrtThreadingOptions* tp_options, OrtCustomCreateThreadFn ort_custom_create_thread_fn) __attribute__((warn_unused_result))
pub const IDX_SET_GLOBAL_CUSTOM_CREATE_THREAD_FN: usize = 199;
pub type SetGlobalCustomCreateThreadFnFn = unsafe extern "C" fn(
    tp_options: *mut ThreadingOptionsHandle,
    ort_custom_create_thread_fn: CustomCreateThreadFnHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_global_custom_create_thread_fn(&self) -> SetGlobalCustomCreateThreadFnFn {
        self.f(IDX_SET_GLOBAL_CUSTOM_CREATE_THREAD_FN)
    }
}

// OrtStatusPtr(* SetGlobalCustomThreadCreationOptions)( OrtThreadingOptions* tp_options, void* ort_custom_thread_creation_options) __attribute__((warn_unused_result))
pub const IDX_SET_GLOBAL_CUSTOM_THREAD_CREATION_OPTIONS: usize = 200;
pub type SetGlobalCustomThreadCreationOptionsFn = unsafe extern "C" fn(
    tp_options: *mut ThreadingOptionsHandle,
    ort_custom_thread_creation_options: *mut core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_global_custom_thread_creation_options(
        &self,
    ) -> SetGlobalCustomThreadCreationOptionsFn {
        self.f(IDX_SET_GLOBAL_CUSTOM_THREAD_CREATION_OPTIONS)
    }
}

// OrtStatusPtr(* SetGlobalCustomJoinThreadFn)( OrtThreadingOptions* tp_options, OrtCustomJoinThreadFn ort_custom_join_thread_fn) __attribute__((warn_unused_result))
pub const IDX_SET_GLOBAL_CUSTOM_JOIN_THREAD_FN: usize = 201;
pub type SetGlobalCustomJoinThreadFnFn = unsafe extern "C" fn(
    tp_options: *mut ThreadingOptionsHandle,
    ort_custom_join_thread_fn: CustomJoinThreadFnHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_global_custom_join_thread_fn(&self) -> SetGlobalCustomJoinThreadFnFn {
        self.f(IDX_SET_GLOBAL_CUSTOM_JOIN_THREAD_FN)
    }
}

// OrtStatusPtr(* SynchronizeBoundInputs)( OrtIoBinding* binding_ptr) __attribute__((warn_unused_result))
pub const IDX_SYNCHRONIZE_BOUND_INPUTS: usize = 202;
pub type SynchronizeBoundInputsFn =
    unsafe extern "C" fn(binding_ptr: *mut IoBindingHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn synchronize_bound_inputs(&self) -> SynchronizeBoundInputsFn {
        self.f(IDX_SYNCHRONIZE_BOUND_INPUTS)
    }
}

// OrtStatusPtr(* SynchronizeBoundOutputs)( OrtIoBinding* binding_ptr) __attribute__((warn_unused_result))
pub const IDX_SYNCHRONIZE_BOUND_OUTPUTS: usize = 203;
pub type SynchronizeBoundOutputsFn =
    unsafe extern "C" fn(binding_ptr: *mut IoBindingHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn synchronize_bound_outputs(&self) -> SynchronizeBoundOutputsFn {
        self.f(IDX_SYNCHRONIZE_BOUND_OUTPUTS)
    }
}

// OrtStatusPtr(* AddExternalInitializers)( OrtSessionOptions* options, const char* const* initializer_names, const OrtValue* const* initializers, size_t num_initializers) __attribute__((warn_unused_result))
pub const IDX_ADD_EXTERNAL_INITIALIZERS: usize = 210;
pub type AddExternalInitializersFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    initializer_names: *const *const core::ffi::c_char,
    initializers: *const *const ValueHandle,
    num_initializers: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn add_external_initializers(&self) -> AddExternalInitializersFn {
        self.f(IDX_ADD_EXTERNAL_INITIALIZERS)
    }
}

// OrtStatusPtr(* CreateOpAttr)( const char* name, const void* data, int len, OrtOpAttrType type, OrtOpAttr** op_attr) __attribute__((warn_unused_result))
pub const IDX_CREATE_OP_ATTR: usize = 211;
pub type CreateOpAttrFn = unsafe extern "C" fn(
    name: *const core::ffi::c_char,
    data: *const core::ffi::c_void,
    len: core::ffi::c_int,
    type_: OpAttrType,
    op_attr: *mut *mut OpAttrHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_op_attr(&self) -> CreateOpAttrFn {
        self.f(IDX_CREATE_OP_ATTR)
    }
}

// OrtStatusPtr(* InvokeOp)( const OrtKernelContext* context, const OrtOp* ort_op, const OrtValue* const* input_values, int input_count, OrtValue* const* output_values, int output_count) __attribute__((warn_unused_result))
pub const IDX_INVOKE_OP: usize = 214;
pub type InvokeOpFn = unsafe extern "C" fn(
    context: *const KernelContextHandle,
    ort_op: *const OpHandle,
    input_values: *const *const ValueHandle,
    input_count: core::ffi::c_int,
    output_values: *mut *mut ValueHandle,
    output_count: core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn invoke_op(&self) -> InvokeOpFn {
        self.f(IDX_INVOKE_OP)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider)( OrtSessionOptions* options, const char* provider_name, const char* const* provider_options_keys, const char* const* provider_options_values, size_t num_keys) __attribute__((warn_unused_result))
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER: usize = 216;
pub type SessionOptionsAppendExecutionProviderFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    provider_name: *const core::ffi::c_char,
    provider_options_keys: *const *const core::ffi::c_char,
    provider_options_values: *const *const core::ffi::c_char,
    num_keys: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_options_append_execution_provider(
        &self,
    ) -> SessionOptionsAppendExecutionProviderFn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER)
    }
}

// OrtStatusPtr(* CopyKernelInfo)( const OrtKernelInfo* info, OrtKernelInfo** info_copy) __attribute__((warn_unused_result))
pub const IDX_COPY_KERNEL_INFO: usize = 217;
pub type CopyKernelInfoFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    info_copy: *mut *mut KernelInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn copy_kernel_info(&self) -> CopyKernelInfoFn {
        self.f(IDX_COPY_KERNEL_INFO)
    }
}

// void(* MemoryInfoGetDeviceType)( const OrtMemoryInfo* ptr, OrtMemoryInfoDeviceType* out)
pub const IDX_MEMORY_INFO_GET_DEVICE_TYPE: usize = 225;
pub type MemoryInfoGetDeviceTypeFn =
    unsafe extern "C" fn(ptr: *const MemoryInfoHandle, out_: *mut MemoryInfoDeviceTypeHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn memory_info_get_device_type(&self) -> MemoryInfoGetDeviceTypeFn {
        self.f(IDX_MEMORY_INFO_GET_DEVICE_TYPE)
    }
}

// OrtStatusPtr(* UpdateEnvWithCustomLogLevel)( OrtEnv* ort_env, OrtLoggingLevel log_severity_level) __attribute__((warn_unused_result))
pub const IDX_UPDATE_ENV_WITH_CUSTOM_LOG_LEVEL: usize = 226;
pub type UpdateEnvWithCustomLogLevelFn =
    unsafe extern "C" fn(ort_env: *mut EnvHandle, log_severity_level: LoggingLevel) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn update_env_with_custom_log_level(&self) -> UpdateEnvWithCustomLogLevelFn {
        self.f(IDX_UPDATE_ENV_WITH_CUSTOM_LOG_LEVEL)
    }
}

// OrtStatusPtr(* SetGlobalIntraOpThreadAffinity)( OrtThreadingOptions* tp_options, const char* affinity_string) __attribute__((warn_unused_result))
pub const IDX_SET_GLOBAL_INTRA_OP_THREAD_AFFINITY: usize = 227;
pub type SetGlobalIntraOpThreadAffinityFn = unsafe extern "C" fn(
    tp_options: *mut ThreadingOptionsHandle,
    affinity_string: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_global_intra_op_thread_affinity(&self) -> SetGlobalIntraOpThreadAffinityFn {
        self.f(IDX_SET_GLOBAL_INTRA_OP_THREAD_AFFINITY)
    }
}

// OrtStatusPtr(* RegisterCustomOpsLibrary_V2)( OrtSessionOptions* options, const char* library_name) __attribute__((warn_unused_result))
pub const IDX_REGISTER_CUSTOM_OPS_LIBRARY_V2: usize = 228;
pub type RegisterCustomOpsLibrary_v2Fn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    library_name: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn register_custom_ops_library_v2(&self) -> RegisterCustomOpsLibrary_v2Fn {
        self.f(IDX_REGISTER_CUSTOM_OPS_LIBRARY_V2)
    }
}

// OrtStatusPtr(* RegisterCustomOpsUsingFunction)( OrtSessionOptions* options, const char* registration_func_name) __attribute__((warn_unused_result))
pub const IDX_REGISTER_CUSTOM_OPS_USING_FUNCTION: usize = 229;
pub type RegisterCustomOpsUsingFunctionFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    registration_func_name: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn register_custom_ops_using_function(&self) -> RegisterCustomOpsUsingFunctionFn {
        self.f(IDX_REGISTER_CUSTOM_OPS_USING_FUNCTION)
    }
}

// OrtStatusPtr(* HasSessionConfigEntry)( const OrtSessionOptions* options, const char* config_key, int* out) __attribute__((warn_unused_result))
pub const IDX_HAS_SESSION_CONFIG_ENTRY: usize = 237;
pub type HasSessionConfigEntryFn = unsafe extern "C" fn(
    options: *const SessionOptionsHandle,
    config_key: *const core::ffi::c_char,
    out_: *mut core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn has_session_config_entry(&self) -> HasSessionConfigEntryFn {
        self.f(IDX_HAS_SESSION_CONFIG_ENTRY)
    }
}

// OrtStatusPtr(* GetSessionConfigEntry)( const OrtSessionOptions* options, const char* config_key, char* config_value, size_t* size) __attribute__((warn_unused_result))
pub const IDX_GET_SESSION_CONFIG_ENTRY: usize = 238;
pub type GetSessionConfigEntryFn = unsafe extern "C" fn(
    options: *const SessionOptionsHandle,
    config_key: *const core::ffi::c_char,
    config_value: *mut core::ffi::c_char,
    size: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_session_config_entry(&self) -> GetSessionConfigEntryFn {
        self.f(IDX_GET_SESSION_CONFIG_ENTRY)
    }
}

// OrtStatusPtr(* Logger_LogMessage)( const OrtLogger* logger, OrtLoggingLevel log_severity_level, const char* message, const char* file_path, int line_number, const char* func_name) __attribute__((warn_unused_result))
pub const IDX_LOGGER__LOG_MESSAGE: usize = 247;
pub type Logger_LogMessageFn = unsafe extern "C" fn(
    logger: *const LoggerHandle,
    log_severity_level: LoggingLevel,
    message: *const core::ffi::c_char,
    file_path: *const core::ffi::c_char,
    line_number: core::ffi::c_int,
    func_name: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn logger__log_message(&self) -> Logger_LogMessageFn {
        self.f(IDX_LOGGER__LOG_MESSAGE)
    }
}

// OrtStatusPtr(* Logger_GetLoggingSeverityLevel)( const OrtLogger* logger, OrtLoggingLevel* out) __attribute__((warn_unused_result))
pub const IDX_LOGGER__GET_LOGGING_SEVERITY_LEVEL: usize = 248;
pub type Logger_GetLoggingSeverityLevelFn =
    unsafe extern "C" fn(logger: *const LoggerHandle, out_: *mut LoggingLevel) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn logger__get_logging_severity_level(&self) -> Logger_GetLoggingSeverityLevelFn {
        self.f(IDX_LOGGER__GET_LOGGING_SEVERITY_LEVEL)
    }
}

// OrtStatusPtr(* CastTypeInfoToOptionalTypeInfo)( const OrtTypeInfo* type_info, const OrtOptionalTypeInfo** out) __attribute__((warn_unused_result))
pub const IDX_CAST_TYPE_INFO_TO_OPTIONAL_TYPE_INFO: usize = 250;
pub type CastTypeInfoToOptionalTypeInfoFn = unsafe extern "C" fn(
    type_info: *const TypeInfoHandle,
    out_: *const *const OptionalTypeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn cast_type_info_to_optional_type_info(&self) -> CastTypeInfoToOptionalTypeInfoFn {
        self.f(IDX_CAST_TYPE_INFO_TO_OPTIONAL_TYPE_INFO)
    }
}

// OrtStatusPtr(* GetOptionalContainedTypeInfo)( const OrtOptionalTypeInfo* optional_type_info, OrtTypeInfo** out) __attribute__((warn_unused_result))
pub const IDX_GET_OPTIONAL_CONTAINED_TYPE_INFO: usize = 251;
pub type GetOptionalContainedTypeInfoFn = unsafe extern "C" fn(
    optional_type_info: *const OptionalTypeInfoHandle,
    out_: *mut *mut TypeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_optional_contained_type_info(&self) -> GetOptionalContainedTypeInfoFn {
        self.f(IDX_GET_OPTIONAL_CONTAINED_TYPE_INFO)
    }
}

// OrtStatusPtr(* GetResizedStringTensorElementBuffer)( OrtValue* value, size_t index, size_t length_in_bytes, char** buffer) __attribute__((warn_unused_result))
pub const IDX_GET_RESIZED_STRING_TENSOR_ELEMENT_BUFFER: usize = 252;
pub type GetResizedStringTensorElementBufferFn = unsafe extern "C" fn(
    value: *mut ValueHandle,
    index: usize,
    length_in_bytes: usize,
    buffer: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_resized_string_tensor_element_buffer(
        &self,
    ) -> GetResizedStringTensorElementBufferFn {
        self.f(IDX_GET_RESIZED_STRING_TENSOR_ELEMENT_BUFFER)
    }
}

// const char*(* GetBuildInfoString)(void)
pub const IDX_GET_BUILD_INFO_STRING: usize = 254;
pub type GetBuildInfoStringFn = unsafe extern "C" fn() -> *const core::ffi::c_char;
impl Api {
    #[inline]
    pub unsafe fn get_build_info_string(&self) -> GetBuildInfoStringFn {
        self.f(IDX_GET_BUILD_INFO_STRING)
    }
}

// OrtStatusPtr(* CreateAndRegisterAllocatorV2)( OrtEnv* env, const char* provider_type, const OrtMemoryInfo* mem_info, const OrtArenaCfg* arena_cfg, const char* const* provider_options_keys, const char* const* provider_options_values, size_t num_keys) __attribute__((warn_unused_result))
pub const IDX_CREATE_AND_REGISTER_ALLOCATOR_V2: usize = 259;
pub type CreateAndRegisterAllocatorV2Fn = unsafe extern "C" fn(
    env: *mut EnvHandle,
    provider_type: *const core::ffi::c_char,
    mem_info: *const MemoryInfoHandle,
    arena_cfg: *const ArenaCfgHandle,
    provider_options_keys: *const *const core::ffi::c_char,
    provider_options_values: *const *const core::ffi::c_char,
    num_keys: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_and_register_allocator_v2(&self) -> CreateAndRegisterAllocatorV2Fn {
        self.f(IDX_CREATE_AND_REGISTER_ALLOCATOR_V2)
    }
}

// OrtStatusPtr(* RunAsync)( OrtSession* session, const OrtRunOptions* run_options, const char* const* input_names, const OrtValue* const* input, size_t input_len, const char* const* output_names, size_t output_names_len, OrtValue** output, RunAsyncCallbackFn run_async_callback, void* user_data) __attribute__((warn_unused_result))
pub const IDX_RUN_ASYNC: usize = 260;
pub type RunAsyncFn = unsafe extern "C" fn(
    session: *mut SessionHandle,
    run_options: *const RunOptionsHandle,
    input_names: *const *const core::ffi::c_char,
    input: *const *const ValueHandle,
    input_len: usize,
    output_names: *const *const core::ffi::c_char,
    output_names_len: usize,
    output: *mut *mut ValueHandle,
    run_async_callback: Option<
        unsafe extern "C" fn(*mut core::ffi::c_void, *mut *mut ValueHandle, usize, StatusPtr),
    >,
    user_data: *mut core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_async(&self) -> RunAsyncFn {
        self.f(IDX_RUN_ASYNC)
    }
}

// OrtStatusPtr(* SetUserLoggingFunction)( OrtSessionOptions* options, OrtLoggingFunction user_logging_function, void* user_logging_param) __attribute__((warn_unused_result))
pub const IDX_SET_USER_LOGGING_FUNCTION: usize = 266;
pub type SetUserLoggingFunctionFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    user_logging_function: LoggingFunction,
    user_logging_param: *mut core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_user_logging_function(&self) -> SetUserLoggingFunctionFn {
        self.f(IDX_SET_USER_LOGGING_FUNCTION)
    }
}

// OrtStatusPtr(* ShapeInferContext_GetInputCount)( const OrtShapeInferContext* context, size_t* out) __attribute__((warn_unused_result))
pub const IDX_SHAPE_INFER_CONTEXT__GET_INPUT_COUNT: usize = 267;
pub type ShapeInferContext_GetInputCountFn =
    unsafe extern "C" fn(context: *const ShapeInferContextHandle, out_: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn shape_infer_context__get_input_count(&self) -> ShapeInferContext_GetInputCountFn {
        self.f(IDX_SHAPE_INFER_CONTEXT__GET_INPUT_COUNT)
    }
}

// OrtStatusPtr(* ShapeInferContext_GetInputTypeShape)( const OrtShapeInferContext* context, size_t index, OrtTensorTypeAndShapeInfo** info) __attribute__((warn_unused_result))
pub const IDX_SHAPE_INFER_CONTEXT__GET_INPUT_TYPE_SHAPE: usize = 268;
pub type ShapeInferContext_GetInputTypeShapeFn = unsafe extern "C" fn(
    context: *const ShapeInferContextHandle,
    index: usize,
    info: *mut *mut TensorTypeAndShapeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn shape_infer_context__get_input_type_shape(
        &self,
    ) -> ShapeInferContext_GetInputTypeShapeFn {
        self.f(IDX_SHAPE_INFER_CONTEXT__GET_INPUT_TYPE_SHAPE)
    }
}

// OrtStatusPtr(* ShapeInferContext_GetAttribute)( const OrtShapeInferContext* context, const char* attr_name, const OrtOpAttr** attr) __attribute__((warn_unused_result))
pub const IDX_SHAPE_INFER_CONTEXT__GET_ATTRIBUTE: usize = 269;
pub type ShapeInferContext_GetAttributeFn = unsafe extern "C" fn(
    context: *const ShapeInferContextHandle,
    attr_name: *const core::ffi::c_char,
    attr: *const *const OpAttrHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn shape_infer_context__get_attribute(&self) -> ShapeInferContext_GetAttributeFn {
        self.f(IDX_SHAPE_INFER_CONTEXT__GET_ATTRIBUTE)
    }
}

// OrtStatusPtr(* ShapeInferContext_SetOutputTypeShape)( const OrtShapeInferContext* context, size_t index, const OrtTensorTypeAndShapeInfo* info) __attribute__((warn_unused_result))
pub const IDX_SHAPE_INFER_CONTEXT__SET_OUTPUT_TYPE_SHAPE: usize = 270;
pub type ShapeInferContext_SetOutputTypeShapeFn = unsafe extern "C" fn(
    context: *const ShapeInferContextHandle,
    index: usize,
    info: *const TensorTypeAndShapeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn shape_infer_context__set_output_type_shape(
        &self,
    ) -> ShapeInferContext_SetOutputTypeShapeFn {
        self.f(IDX_SHAPE_INFER_CONTEXT__SET_OUTPUT_TYPE_SHAPE)
    }
}

// OrtStatusPtr(* SetSymbolicDimensions)( OrtTensorTypeAndShapeInfo* info, const char* dim_params[], size_t dim_params_length) __attribute__((warn_unused_result))
pub const IDX_SET_SYMBOLIC_DIMENSIONS: usize = 271;
pub type SetSymbolicDimensionsFn = unsafe extern "C" fn(
    info: *mut TensorTypeAndShapeInfoHandle,
    dim_params: *const *const core::ffi::c_char,
    dim_params_length: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_symbolic_dimensions(&self) -> SetSymbolicDimensionsFn {
        self.f(IDX_SET_SYMBOLIC_DIMENSIONS)
    }
}

// OrtStatusPtr(* ReadOpAttr)( const OrtOpAttr* op_attr, OrtOpAttrType type, void* data, size_t len, size_t* out) __attribute__((warn_unused_result))
pub const IDX_READ_OP_ATTR: usize = 272;
pub type ReadOpAttrFn = unsafe extern "C" fn(
    op_attr: *const OpAttrHandle,
    type_: OpAttrType,
    data: *mut core::ffi::c_void,
    len: usize,
    out_: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn read_op_attr(&self) -> ReadOpAttrFn {
        self.f(IDX_READ_OP_ATTR)
    }
}

// OrtStatusPtr(* SetDeterministicCompute)( OrtSessionOptions* options, bool value) __attribute__((warn_unused_result))
pub const IDX_SET_DETERMINISTIC_COMPUTE: usize = 273;
pub type SetDeterministicComputeFn =
    unsafe extern "C" fn(options: *mut SessionOptionsHandle, value: bool) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_deterministic_compute(&self) -> SetDeterministicComputeFn {
        self.f(IDX_SET_DETERMINISTIC_COMPUTE)
    }
}

// OrtStatusPtr(* AddExternalInitializersFromFilesInMemory)( OrtSessionOptions* options, const char* const* external_initializer_file_names, char* const* external_initializer_file_buffer_array, const size_t* external_initializer_file_lengths, size_t num_external_initializer_files) __attribute__((warn_unused_result))
pub const IDX_ADD_EXTERNAL_INITIALIZERS_FROM_FILES_IN_MEMORY: usize = 279;
pub type AddExternalInitializersFromFilesInMemoryFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    external_initializer_file_names: *const *const core::ffi::c_char,
    external_initializer_file_buffer_array: *mut *mut core::ffi::c_char,
    external_initializer_file_lengths: *const usize,
    num_external_initializer_files: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn add_external_initializers_from_files_in_memory(
        &self,
    ) -> AddExternalInitializersFromFilesInMemoryFn {
        self.f(IDX_ADD_EXTERNAL_INITIALIZERS_FROM_FILES_IN_MEMORY)
    }
}

// OrtStatusPtr(* CreateLoraAdapter)(const char* adapter_file_path, OrtAllocator* allocator, OrtLoraAdapter** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_LORA_ADAPTER: usize = 280;
pub type CreateLoraAdapterFn = unsafe extern "C" fn(
    adapter_file_path: *const core::ffi::c_char,
    allocator: *mut AllocatorHandle,
    out_: *mut *mut LoraAdapterHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_lora_adapter(&self) -> CreateLoraAdapterFn {
        self.f(IDX_CREATE_LORA_ADAPTER)
    }
}

// OrtStatusPtr(* CreateLoraAdapterFromArray)( const void* bytes, size_t num_bytes, OrtAllocator* allocator, OrtLoraAdapter** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_LORA_ADAPTER_FROM_ARRAY: usize = 281;
pub type CreateLoraAdapterFromArrayFn = unsafe extern "C" fn(
    bytes: *const core::ffi::c_void,
    num_bytes: usize,
    allocator: *mut AllocatorHandle,
    out_: *mut *mut LoraAdapterHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_lora_adapter_from_array(&self) -> CreateLoraAdapterFromArrayFn {
        self.f(IDX_CREATE_LORA_ADAPTER_FROM_ARRAY)
    }
}

// void( * ReleaseLoraAdapter)( OrtLoraAdapter * input)
pub const IDX_RELEASE_LORA_ADAPTER: usize = 282;
pub type ReleaseLoraAdapterFn = unsafe extern "C" fn(input: *mut LoraAdapterHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_lora_adapter(&self) -> ReleaseLoraAdapterFn {
        self.f(IDX_RELEASE_LORA_ADAPTER)
    }
}

// OrtStatusPtr(* RunOptionsAddActiveLoraAdapter)( OrtRunOptions* options, const OrtLoraAdapter* adapter) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_ADD_ACTIVE_LORA_ADAPTER: usize = 283;
pub type RunOptionsAddActiveLoraAdapterFn = unsafe extern "C" fn(
    options: *mut RunOptionsHandle,
    adapter: *const LoraAdapterHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_add_active_lora_adapter(&self) -> RunOptionsAddActiveLoraAdapterFn {
        self.f(IDX_RUN_OPTIONS_ADD_ACTIVE_LORA_ADAPTER)
    }
}

// OrtStatusPtr(* SetEpDynamicOptions)( OrtSession* sess, const char* const* keys, const char* const* values, size_t kv_len) __attribute__((warn_unused_result))
pub const IDX_SET_EP_DYNAMIC_OPTIONS: usize = 284;
pub type SetEpDynamicOptionsFn = unsafe extern "C" fn(
    sess: *mut SessionHandle,
    keys: *const *const core::ffi::c_char,
    values: *const *const core::ffi::c_char,
    kv_len: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_ep_dynamic_options(&self) -> SetEpDynamicOptionsFn {
        self.f(IDX_SET_EP_DYNAMIC_OPTIONS)
    }
}

// void( * ReleaseValueInfo)( OrtValueInfo * input)
pub const IDX_RELEASE_VALUE_INFO: usize = 285;
pub type ReleaseValueInfoFn = unsafe extern "C" fn(input: *mut ValueInfoHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_value_info(&self) -> ReleaseValueInfoFn {
        self.f(IDX_RELEASE_VALUE_INFO)
    }
}

// void( * ReleaseNode)( OrtNode * input)
pub const IDX_RELEASE_NODE: usize = 286;
pub type ReleaseNodeFn = unsafe extern "C" fn(input: *mut NodeHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_node(&self) -> ReleaseNodeFn {
        self.f(IDX_RELEASE_NODE)
    }
}

// void( * ReleaseGraph)( OrtGraph * input)
pub const IDX_RELEASE_GRAPH: usize = 287;
pub type ReleaseGraphFn = unsafe extern "C" fn(input: *mut GraphHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_graph(&self) -> ReleaseGraphFn {
        self.f(IDX_RELEASE_GRAPH)
    }
}

// void( * ReleaseModel)( OrtModel * input)
pub const IDX_RELEASE_MODEL: usize = 288;
pub type ReleaseModelFn = unsafe extern "C" fn(input: *mut ModelHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_model(&self) -> ReleaseModelFn {
        self.f(IDX_RELEASE_MODEL)
    }
}

// OrtStatusPtr(* GetValueInfoName)( const OrtValueInfo* value_info, const char** name) __attribute__((warn_unused_result))
pub const IDX_GET_VALUE_INFO_NAME: usize = 289;
pub type GetValueInfoNameFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    name: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_value_info_name(&self) -> GetValueInfoNameFn {
        self.f(IDX_GET_VALUE_INFO_NAME)
    }
}

// OrtStatusPtr(* GetValueInfoTypeInfo)( const OrtValueInfo* value_info, const OrtTypeInfo** type_info) __attribute__((warn_unused_result))
pub const IDX_GET_VALUE_INFO_TYPE_INFO: usize = 290;
pub type GetValueInfoTypeInfoFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    type_info: *const *const TypeInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_value_info_type_info(&self) -> GetValueInfoTypeInfoFn {
        self.f(IDX_GET_VALUE_INFO_TYPE_INFO)
    }
}

// OrtStatusPtr(* CreateTensorWithDataAndDeleterAsOrtValue)( OrtAllocator* deleter, void* p_data, size_t p_data_len, const int64_t* shape, size_t shape_len, ONNXTensorElementDataType type, OrtValue** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_TENSOR_WITH_DATA_AND_DELETER_AS_ORT_VALUE: usize = 292;
pub type CreateTensorWithDataAndDeleterAsOrtValueFn = unsafe extern "C" fn(
    deleter: *mut AllocatorHandle,
    p_data: *mut core::ffi::c_void,
    p_data_len: usize,
    shape: *const i64,
    shape_len: usize,
    type_: ElementType,
    out_: *mut *mut ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_tensor_with_data_and_deleter_as_ort_value(
        &self,
    ) -> CreateTensorWithDataAndDeleterAsOrtValueFn {
        self.f(IDX_CREATE_TENSOR_WITH_DATA_AND_DELETER_AS_ORT_VALUE)
    }
}

// OrtStatusPtr(* SessionOptionsSetLoadCancellationFlag)( OrtSessionOptions* options, bool cancel) __attribute__((warn_unused_result))
pub const IDX_SESSION_OPTIONS_SET_LOAD_CANCELLATION_FLAG: usize = 293;
pub type SessionOptionsSetLoadCancellationFlagFn =
    unsafe extern "C" fn(options: *mut SessionOptionsHandle, cancel: bool) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_options_set_load_cancellation_flag(
        &self,
    ) -> SessionOptionsSetLoadCancellationFlagFn {
        self.f(IDX_SESSION_OPTIONS_SET_LOAD_CANCELLATION_FLAG)
    }
}

// void(* CreateKeyValuePairs)( OrtKeyValuePairs** out)
pub const IDX_CREATE_KEY_VALUE_PAIRS: usize = 295;
pub type CreateKeyValuePairsFn = unsafe extern "C" fn(out_: *mut *mut KeyValuePairsHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn create_key_value_pairs(&self) -> CreateKeyValuePairsFn {
        self.f(IDX_CREATE_KEY_VALUE_PAIRS)
    }
}

// void(* AddKeyValuePair)( OrtKeyValuePairs* kvps, const char* key, const char* value)
pub const IDX_ADD_KEY_VALUE_PAIR: usize = 296;
pub type AddKeyValuePairFn = unsafe extern "C" fn(
    kvps: *mut KeyValuePairsHandle,
    key: *const core::ffi::c_char,
    value: *const core::ffi::c_char,
) -> ();
impl Api {
    #[inline]
    pub unsafe fn add_key_value_pair(&self) -> AddKeyValuePairFn {
        self.f(IDX_ADD_KEY_VALUE_PAIR)
    }
}

// const char*(* GetKeyValue)( const OrtKeyValuePairs* kvps, const char* key)
pub const IDX_GET_KEY_VALUE: usize = 297;
pub type GetKeyValueFn = unsafe extern "C" fn(
    kvps: *const KeyValuePairsHandle,
    key: *const core::ffi::c_char,
) -> *const core::ffi::c_char;
impl Api {
    #[inline]
    pub unsafe fn get_key_value(&self) -> GetKeyValueFn {
        self.f(IDX_GET_KEY_VALUE)
    }
}

// void(* GetKeyValuePairs)( const OrtKeyValuePairs* kvps, const char* const** keys, const char* const** values, size_t* num_entries)
pub const IDX_GET_KEY_VALUE_PAIRS: usize = 298;
pub type GetKeyValuePairsFn = unsafe extern "C" fn(
    kvps: *const KeyValuePairsHandle,
    keys: *const *const *const core::ffi::c_char,
    values: *const *const *const core::ffi::c_char,
    num_entries: *mut usize,
) -> ();
impl Api {
    #[inline]
    pub unsafe fn get_key_value_pairs(&self) -> GetKeyValuePairsFn {
        self.f(IDX_GET_KEY_VALUE_PAIRS)
    }
}

// void(* RemoveKeyValuePair)( OrtKeyValuePairs* kvps, const char* key)
pub const IDX_REMOVE_KEY_VALUE_PAIR: usize = 299;
pub type RemoveKeyValuePairFn =
    unsafe extern "C" fn(kvps: *mut KeyValuePairsHandle, key: *const core::ffi::c_char) -> ();
impl Api {
    #[inline]
    pub unsafe fn remove_key_value_pair(&self) -> RemoveKeyValuePairFn {
        self.f(IDX_REMOVE_KEY_VALUE_PAIR)
    }
}

// void( * ReleaseKeyValuePairs)( OrtKeyValuePairs * input)
pub const IDX_RELEASE_KEY_VALUE_PAIRS: usize = 300;
pub type ReleaseKeyValuePairsFn = unsafe extern "C" fn(input: *mut KeyValuePairsHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_key_value_pairs(&self) -> ReleaseKeyValuePairsFn {
        self.f(IDX_RELEASE_KEY_VALUE_PAIRS)
    }
}

// OrtStatusPtr(* RegisterExecutionProviderLibrary)( OrtEnv* env, const char* registration_name, const char* path) __attribute__((warn_unused_result))
pub const IDX_REGISTER_EXECUTION_PROVIDER_LIBRARY: usize = 301;
pub type RegisterExecutionProviderLibraryFn = unsafe extern "C" fn(
    env: *mut EnvHandle,
    registration_name: *const core::ffi::c_char,
    path: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn register_execution_provider_library(&self) -> RegisterExecutionProviderLibraryFn {
        self.f(IDX_REGISTER_EXECUTION_PROVIDER_LIBRARY)
    }
}

// OrtStatusPtr(* UnregisterExecutionProviderLibrary)( OrtEnv* env, const char* registration_name) __attribute__((warn_unused_result))
pub const IDX_UNREGISTER_EXECUTION_PROVIDER_LIBRARY: usize = 302;
pub type UnregisterExecutionProviderLibraryFn = unsafe extern "C" fn(
    env: *mut EnvHandle,
    registration_name: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn unregister_execution_provider_library(
        &self,
    ) -> UnregisterExecutionProviderLibraryFn {
        self.f(IDX_UNREGISTER_EXECUTION_PROVIDER_LIBRARY)
    }
}

// OrtStatusPtr(* GetEpDevices)( const OrtEnv* env, const OrtEpDevice* const** ep_devices, size_t* num_ep_devices) __attribute__((warn_unused_result))
pub const IDX_GET_EP_DEVICES: usize = 303;
pub type GetEpDevicesFn = unsafe extern "C" fn(
    env: *const EnvHandle,
    ep_devices: *const *const *const EpDeviceHandle,
    num_ep_devices: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_ep_devices(&self) -> GetEpDevicesFn {
        self.f(IDX_GET_EP_DEVICES)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_V2)( OrtSessionOptions* session_options, OrtEnv* env, const OrtEpDevice* const* ep_devices, size_t num_ep_devices, const char* const* ep_option_keys, const char* const* ep_option_vals, size_t num_ep_options) __attribute__((warn_unused_result))
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_V2: usize = 304;
pub type SessionOptionsAppendExecutionProvider_v2Fn = unsafe extern "C" fn(
    session_options: *mut SessionOptionsHandle,
    env: *mut EnvHandle,
    ep_devices: *const *const EpDeviceHandle,
    num_ep_devices: usize,
    ep_option_keys: *const *const core::ffi::c_char,
    ep_option_vals: *const *const core::ffi::c_char,
    num_ep_options: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_options_append_execution_provider_v2(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_v2Fn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_V2)
    }
}

// OrtStatusPtr(* SessionOptionsSetEpSelectionPolicy)( OrtSessionOptions* session_options, OrtExecutionProviderDevicePolicy policy) __attribute__((warn_unused_result))
pub const IDX_SESSION_OPTIONS_SET_EP_SELECTION_POLICY: usize = 305;
pub type SessionOptionsSetEpSelectionPolicyFn = unsafe extern "C" fn(
    session_options: *mut SessionOptionsHandle,
    policy: ExecutionProviderDevicePolicyHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_options_set_ep_selection_policy(
        &self,
    ) -> SessionOptionsSetEpSelectionPolicyFn {
        self.f(IDX_SESSION_OPTIONS_SET_EP_SELECTION_POLICY)
    }
}

// OrtStatusPtr(* SessionOptionsSetEpSelectionPolicyDelegate)( OrtSessionOptions* session_options, EpSelectionDelegate delegate, void* delegate_state) __attribute__((warn_unused_result))
pub const IDX_SESSION_OPTIONS_SET_EP_SELECTION_POLICY_DELEGATE: usize = 306;
pub type SessionOptionsSetEpSelectionPolicyDelegateFn = unsafe extern "C" fn(
    session_options: *mut SessionOptionsHandle,
    delegate: core::ffi::c_void,
    delegate_state: *mut core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_options_set_ep_selection_policy_delegate(
        &self,
    ) -> SessionOptionsSetEpSelectionPolicyDelegateFn {
        self.f(IDX_SESSION_OPTIONS_SET_EP_SELECTION_POLICY_DELEGATE)
    }
}

// OrtHardwareDeviceType(* HardwareDevice_Type)( const OrtHardwareDevice* device)
pub const IDX_HARDWARE_DEVICE__TYPE: usize = 307;
pub type HardwareDevice_TypeFn = unsafe extern "C" fn(device: *const HardwareDeviceHandle) -> i32;
impl Api {
    #[inline]
    pub unsafe fn hardware_device__type(&self) -> HardwareDevice_TypeFn {
        self.f(IDX_HARDWARE_DEVICE__TYPE)
    }
}

// uint32_t(* HardwareDevice_VendorId)( const OrtHardwareDevice* device)
pub const IDX_HARDWARE_DEVICE__VENDOR_ID: usize = 308;
pub type HardwareDevice_VendorIdFn =
    unsafe extern "C" fn(device: *const HardwareDeviceHandle) -> u32;
impl Api {
    #[inline]
    pub unsafe fn hardware_device__vendor_id(&self) -> HardwareDevice_VendorIdFn {
        self.f(IDX_HARDWARE_DEVICE__VENDOR_ID)
    }
}

// const char*(* HardwareDevice_Vendor)( const OrtHardwareDevice* device)
pub const IDX_HARDWARE_DEVICE__VENDOR: usize = 309;
pub type HardwareDevice_VendorFn =
    unsafe extern "C" fn(device: *const HardwareDeviceHandle) -> *const core::ffi::c_char;
impl Api {
    #[inline]
    pub unsafe fn hardware_device__vendor(&self) -> HardwareDevice_VendorFn {
        self.f(IDX_HARDWARE_DEVICE__VENDOR)
    }
}

// uint32_t(* HardwareDevice_DeviceId)( const OrtHardwareDevice* device)
pub const IDX_HARDWARE_DEVICE__DEVICE_ID: usize = 310;
pub type HardwareDevice_DeviceIdFn =
    unsafe extern "C" fn(device: *const HardwareDeviceHandle) -> u32;
impl Api {
    #[inline]
    pub unsafe fn hardware_device__device_id(&self) -> HardwareDevice_DeviceIdFn {
        self.f(IDX_HARDWARE_DEVICE__DEVICE_ID)
    }
}

// const OrtKeyValuePairs*(* HardwareDevice_Metadata)( const OrtHardwareDevice* device)
pub const IDX_HARDWARE_DEVICE__METADATA: usize = 311;
pub type HardwareDevice_MetadataFn =
    unsafe extern "C" fn(device: *const HardwareDeviceHandle) -> *const KeyValuePairsHandle;
impl Api {
    #[inline]
    pub unsafe fn hardware_device__metadata(&self) -> HardwareDevice_MetadataFn {
        self.f(IDX_HARDWARE_DEVICE__METADATA)
    }
}

// const char*(* EpDevice_EpName)( const OrtEpDevice* ep_device)
pub const IDX_EP_DEVICE__EP_NAME: usize = 312;
pub type EpDevice_EpNameFn =
    unsafe extern "C" fn(ep_device: *const EpDeviceHandle) -> *const core::ffi::c_char;
impl Api {
    #[inline]
    pub unsafe fn ep_device__ep_name(&self) -> EpDevice_EpNameFn {
        self.f(IDX_EP_DEVICE__EP_NAME)
    }
}

// const char*(* EpDevice_EpVendor)( const OrtEpDevice* ep_device)
pub const IDX_EP_DEVICE__EP_VENDOR: usize = 313;
pub type EpDevice_EpVendorFn =
    unsafe extern "C" fn(ep_device: *const EpDeviceHandle) -> *const core::ffi::c_char;
impl Api {
    #[inline]
    pub unsafe fn ep_device__ep_vendor(&self) -> EpDevice_EpVendorFn {
        self.f(IDX_EP_DEVICE__EP_VENDOR)
    }
}

// const OrtKeyValuePairs*(* EpDevice_EpMetadata)( const OrtEpDevice* ep_device)
pub const IDX_EP_DEVICE__EP_METADATA: usize = 314;
pub type EpDevice_EpMetadataFn =
    unsafe extern "C" fn(ep_device: *const EpDeviceHandle) -> *const KeyValuePairsHandle;
impl Api {
    #[inline]
    pub unsafe fn ep_device__ep_metadata(&self) -> EpDevice_EpMetadataFn {
        self.f(IDX_EP_DEVICE__EP_METADATA)
    }
}

// const OrtKeyValuePairs*(* EpDevice_EpOptions)( const OrtEpDevice* ep_device)
pub const IDX_EP_DEVICE__EP_OPTIONS: usize = 315;
pub type EpDevice_EpOptionsFn =
    unsafe extern "C" fn(ep_device: *const EpDeviceHandle) -> *const KeyValuePairsHandle;
impl Api {
    #[inline]
    pub unsafe fn ep_device__ep_options(&self) -> EpDevice_EpOptionsFn {
        self.f(IDX_EP_DEVICE__EP_OPTIONS)
    }
}

// const OrtHardwareDevice*(* EpDevice_Device)( const OrtEpDevice* ep_device)
pub const IDX_EP_DEVICE__DEVICE: usize = 316;
pub type EpDevice_DeviceFn =
    unsafe extern "C" fn(ep_device: *const EpDeviceHandle) -> *const HardwareDeviceHandle;
impl Api {
    #[inline]
    pub unsafe fn ep_device__device(&self) -> EpDevice_DeviceFn {
        self.f(IDX_EP_DEVICE__DEVICE)
    }
}

// OrtStatusPtr(* GetTensorSizeInBytes)( const OrtValue* ort_value, size_t* size) __attribute__((warn_unused_result))
pub const IDX_GET_TENSOR_SIZE_IN_BYTES: usize = 318;
pub type GetTensorSizeInBytesFn =
    unsafe extern "C" fn(ort_value: *const ValueHandle, size: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_tensor_size_in_bytes(&self) -> GetTensorSizeInBytesFn {
        self.f(IDX_GET_TENSOR_SIZE_IN_BYTES)
    }
}

// OrtStatusPtr(* AllocatorGetStats)( const OrtAllocator* ort_allocator, OrtKeyValuePairs** out) __attribute__((warn_unused_result))
pub const IDX_ALLOCATOR_GET_STATS: usize = 319;
pub type AllocatorGetStatsFn = unsafe extern "C" fn(
    ort_allocator: *const AllocatorHandle,
    out_: *mut *mut KeyValuePairsHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn allocator_get_stats(&self) -> AllocatorGetStatsFn {
        self.f(IDX_ALLOCATOR_GET_STATS)
    }
}

// OrtStatusPtr(* CreateMemoryInfo_V2)( const char* name, enum OrtMemoryInfoDeviceType device_type, uint32_t vendor_id, int32_t device_id, enum OrtDeviceMemoryType mem_type, size_t alignment, enum OrtAllocatorType allocator_type, OrtMemoryInfo** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_MEMORY_INFO_V2: usize = 320;
pub type CreateMemoryInfo_v2Fn = unsafe extern "C" fn(
    name: *const core::ffi::c_char,
    device_type: MemoryInfoDeviceTypeHandle,
    vendor_id: u32,
    device_id: i32,
    mem_type: i32,
    alignment: usize,
    allocator_type: AllocatorType,
    out_: *mut *mut MemoryInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_memory_info_v2(&self) -> CreateMemoryInfo_v2Fn {
        self.f(IDX_CREATE_MEMORY_INFO_V2)
    }
}

// OrtDeviceMemoryType(* MemoryInfoGetDeviceMemType)( const OrtMemoryInfo* ptr)
pub const IDX_MEMORY_INFO_GET_DEVICE_MEM_TYPE: usize = 321;
pub type MemoryInfoGetDeviceMemTypeFn = unsafe extern "C" fn(ptr: *const MemoryInfoHandle) -> i32;
impl Api {
    #[inline]
    pub unsafe fn memory_info_get_device_mem_type(&self) -> MemoryInfoGetDeviceMemTypeFn {
        self.f(IDX_MEMORY_INFO_GET_DEVICE_MEM_TYPE)
    }
}

// uint32_t(* MemoryInfoGetVendorId)( const OrtMemoryInfo* ptr)
pub const IDX_MEMORY_INFO_GET_VENDOR_ID: usize = 322;
pub type MemoryInfoGetVendorIdFn = unsafe extern "C" fn(ptr: *const MemoryInfoHandle) -> u32;
impl Api {
    #[inline]
    pub unsafe fn memory_info_get_vendor_id(&self) -> MemoryInfoGetVendorIdFn {
        self.f(IDX_MEMORY_INFO_GET_VENDOR_ID)
    }
}

// OrtStatusPtr(* ValueInfo_GetValueProducer)( const OrtValueInfo* value_info, const OrtNode** producer_node, size_t* producer_output_index) __attribute__((warn_unused_result))
pub const IDX_VALUE_INFO__GET_VALUE_PRODUCER: usize = 323;
pub type ValueInfo_GetValueProducerFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    producer_node: *const *const NodeHandle,
    producer_output_index: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn value_info__get_value_producer(&self) -> ValueInfo_GetValueProducerFn {
        self.f(IDX_VALUE_INFO__GET_VALUE_PRODUCER)
    }
}

// OrtStatusPtr(* ValueInfo_GetValueNumConsumers)( const OrtValueInfo* value_info, size_t* num_consumers) __attribute__((warn_unused_result))
pub const IDX_VALUE_INFO__GET_VALUE_NUM_CONSUMERS: usize = 324;
pub type ValueInfo_GetValueNumConsumersFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    num_consumers: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn value_info__get_value_num_consumers(&self) -> ValueInfo_GetValueNumConsumersFn {
        self.f(IDX_VALUE_INFO__GET_VALUE_NUM_CONSUMERS)
    }
}

// OrtStatusPtr(* ValueInfo_GetValueConsumers)( const OrtValueInfo* value_info, const OrtNode** nodes, int64_t* input_indices, size_t num_consumers) __attribute__((warn_unused_result))
pub const IDX_VALUE_INFO__GET_VALUE_CONSUMERS: usize = 325;
pub type ValueInfo_GetValueConsumersFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    nodes: *const *const NodeHandle,
    input_indices: *mut i64,
    num_consumers: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn value_info__get_value_consumers(&self) -> ValueInfo_GetValueConsumersFn {
        self.f(IDX_VALUE_INFO__GET_VALUE_CONSUMERS)
    }
}

// OrtStatusPtr(* ValueInfo_GetInitializerValue)( const OrtValueInfo* value_info, const OrtValue** initializer_value) __attribute__((warn_unused_result))
pub const IDX_VALUE_INFO__GET_INITIALIZER_VALUE: usize = 326;
pub type ValueInfo_GetInitializerValueFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    initializer_value: *const *const ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn value_info__get_initializer_value(&self) -> ValueInfo_GetInitializerValueFn {
        self.f(IDX_VALUE_INFO__GET_INITIALIZER_VALUE)
    }
}

// OrtStatusPtr(* ValueInfo_GetExternalInitializerInfo)( const OrtValueInfo* value_info, OrtExternalInitializerInfo** info) __attribute__((warn_unused_result))
pub const IDX_VALUE_INFO__GET_EXTERNAL_INITIALIZER_INFO: usize = 327;
pub type ValueInfo_GetExternalInitializerInfoFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    info: *mut *mut ExternalInitializerInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn value_info__get_external_initializer_info(
        &self,
    ) -> ValueInfo_GetExternalInitializerInfoFn {
        self.f(IDX_VALUE_INFO__GET_EXTERNAL_INITIALIZER_INFO)
    }
}

// OrtStatusPtr(* ValueInfo_IsRequiredGraphInput)( const OrtValueInfo* value_info, bool* is_required_graph_input) __attribute__((warn_unused_result))
pub const IDX_VALUE_INFO__IS_REQUIRED_GRAPH_INPUT: usize = 328;
pub type ValueInfo_IsRequiredGraphInputFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    is_required_graph_input: *mut bool,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn value_info__is_required_graph_input(&self) -> ValueInfo_IsRequiredGraphInputFn {
        self.f(IDX_VALUE_INFO__IS_REQUIRED_GRAPH_INPUT)
    }
}

// OrtStatusPtr(* ValueInfo_IsOptionalGraphInput)( const OrtValueInfo* value_info, bool* is_optional_graph_input) __attribute__((warn_unused_result))
pub const IDX_VALUE_INFO__IS_OPTIONAL_GRAPH_INPUT: usize = 329;
pub type ValueInfo_IsOptionalGraphInputFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    is_optional_graph_input: *mut bool,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn value_info__is_optional_graph_input(&self) -> ValueInfo_IsOptionalGraphInputFn {
        self.f(IDX_VALUE_INFO__IS_OPTIONAL_GRAPH_INPUT)
    }
}

// OrtStatusPtr(* ValueInfo_IsGraphOutput)( const OrtValueInfo* value_info, bool* is_graph_output) __attribute__((warn_unused_result))
pub const IDX_VALUE_INFO__IS_GRAPH_OUTPUT: usize = 330;
pub type ValueInfo_IsGraphOutputFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    is_graph_output: *mut bool,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn value_info__is_graph_output(&self) -> ValueInfo_IsGraphOutputFn {
        self.f(IDX_VALUE_INFO__IS_GRAPH_OUTPUT)
    }
}

// OrtStatusPtr(* ValueInfo_IsConstantInitializer)( const OrtValueInfo* value_info, bool* is_constant_initializer) __attribute__((warn_unused_result))
pub const IDX_VALUE_INFO__IS_CONSTANT_INITIALIZER: usize = 331;
pub type ValueInfo_IsConstantInitializerFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    is_constant_initializer: *mut bool,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn value_info__is_constant_initializer(&self) -> ValueInfo_IsConstantInitializerFn {
        self.f(IDX_VALUE_INFO__IS_CONSTANT_INITIALIZER)
    }
}

// OrtStatusPtr(* ValueInfo_IsFromOuterScope)( const OrtValueInfo* value_info, bool* is_from_outer_scope) __attribute__((warn_unused_result))
pub const IDX_VALUE_INFO__IS_FROM_OUTER_SCOPE: usize = 332;
pub type ValueInfo_IsFromOuterScopeFn = unsafe extern "C" fn(
    value_info: *const ValueInfoHandle,
    is_from_outer_scope: *mut bool,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn value_info__is_from_outer_scope(&self) -> ValueInfo_IsFromOuterScopeFn {
        self.f(IDX_VALUE_INFO__IS_FROM_OUTER_SCOPE)
    }
}

// OrtStatusPtr(* Graph_GetName)( const OrtGraph* graph, const char** graph_name) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_NAME: usize = 333;
pub type Graph_GetNameFn = unsafe extern "C" fn(
    graph: *const GraphHandle,
    graph_name: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_name(&self) -> Graph_GetNameFn {
        self.f(IDX_GRAPH__GET_NAME)
    }
}

// OrtStatusPtr(* Graph_GetModelPath)( const OrtGraph* graph, const char** model_path) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_MODEL_PATH: usize = 334;
pub type Graph_GetModelPathFn = unsafe extern "C" fn(
    graph: *const GraphHandle,
    model_path: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_model_path(&self) -> Graph_GetModelPathFn {
        self.f(IDX_GRAPH__GET_MODEL_PATH)
    }
}

// OrtStatusPtr(* Graph_GetOnnxIRVersion)( const OrtGraph* graph, int64_t* onnx_ir_version) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_ONNX_IR_VERSION: usize = 335;
pub type Graph_GetOnnxIrVersionFn =
    unsafe extern "C" fn(graph: *const GraphHandle, onnx_ir_version: *mut i64) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_onnx_ir_version(&self) -> Graph_GetOnnxIrVersionFn {
        self.f(IDX_GRAPH__GET_ONNX_IR_VERSION)
    }
}

// OrtStatusPtr(* Graph_GetNumOperatorSets)( const OrtGraph* graph, size_t* num_operator_sets) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_NUM_OPERATOR_SETS: usize = 336;
pub type Graph_GetNumOperatorSetsFn =
    unsafe extern "C" fn(graph: *const GraphHandle, num_operator_sets: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_num_operator_sets(&self) -> Graph_GetNumOperatorSetsFn {
        self.f(IDX_GRAPH__GET_NUM_OPERATOR_SETS)
    }
}

// OrtStatusPtr(* Graph_GetOperatorSets)( const OrtGraph* graph, const char** domains, int64_t* opset_versions, size_t num_operator_sets) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_OPERATOR_SETS: usize = 337;
pub type Graph_GetOperatorSetsFn = unsafe extern "C" fn(
    graph: *const GraphHandle,
    domains: *const *const core::ffi::c_char,
    opset_versions: *mut i64,
    num_operator_sets: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_operator_sets(&self) -> Graph_GetOperatorSetsFn {
        self.f(IDX_GRAPH__GET_OPERATOR_SETS)
    }
}

// OrtStatusPtr(* Graph_GetNumInputs)( const OrtGraph* graph, size_t* num_inputs) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_NUM_INPUTS: usize = 338;
pub type Graph_GetNumInputsFn =
    unsafe extern "C" fn(graph: *const GraphHandle, num_inputs: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_num_inputs(&self) -> Graph_GetNumInputsFn {
        self.f(IDX_GRAPH__GET_NUM_INPUTS)
    }
}

// OrtStatusPtr(* Graph_GetInputs)( const OrtGraph* graph, const OrtValueInfo** inputs, size_t num_inputs) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_INPUTS: usize = 339;
pub type Graph_GetInputsFn = unsafe extern "C" fn(
    graph: *const GraphHandle,
    inputs: *const *const ValueInfoHandle,
    num_inputs: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_inputs(&self) -> Graph_GetInputsFn {
        self.f(IDX_GRAPH__GET_INPUTS)
    }
}

// OrtStatusPtr(* Graph_GetNumOutputs)( const OrtGraph* graph, size_t* num_outputs) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_NUM_OUTPUTS: usize = 340;
pub type Graph_GetNumOutputsFn =
    unsafe extern "C" fn(graph: *const GraphHandle, num_outputs: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_num_outputs(&self) -> Graph_GetNumOutputsFn {
        self.f(IDX_GRAPH__GET_NUM_OUTPUTS)
    }
}

// OrtStatusPtr(* Graph_GetOutputs)( const OrtGraph* graph, const OrtValueInfo** outputs, size_t num_outputs) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_OUTPUTS: usize = 341;
pub type Graph_GetOutputsFn = unsafe extern "C" fn(
    graph: *const GraphHandle,
    outputs: *const *const ValueInfoHandle,
    num_outputs: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_outputs(&self) -> Graph_GetOutputsFn {
        self.f(IDX_GRAPH__GET_OUTPUTS)
    }
}

// OrtStatusPtr(* Graph_GetNumInitializers)( const OrtGraph* graph, size_t* num_initializers) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_NUM_INITIALIZERS: usize = 342;
pub type Graph_GetNumInitializersFn =
    unsafe extern "C" fn(graph: *const GraphHandle, num_initializers: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_num_initializers(&self) -> Graph_GetNumInitializersFn {
        self.f(IDX_GRAPH__GET_NUM_INITIALIZERS)
    }
}

// OrtStatusPtr(* Graph_GetInitializers)( const OrtGraph* graph, const OrtValueInfo** initializers, size_t num_initializers) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_INITIALIZERS: usize = 343;
pub type Graph_GetInitializersFn = unsafe extern "C" fn(
    graph: *const GraphHandle,
    initializers: *const *const ValueInfoHandle,
    num_initializers: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_initializers(&self) -> Graph_GetInitializersFn {
        self.f(IDX_GRAPH__GET_INITIALIZERS)
    }
}

// OrtStatusPtr(* Graph_GetNumNodes)( const OrtGraph* graph, size_t* num_nodes) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_NUM_NODES: usize = 344;
pub type Graph_GetNumNodesFn =
    unsafe extern "C" fn(graph: *const GraphHandle, num_nodes: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_num_nodes(&self) -> Graph_GetNumNodesFn {
        self.f(IDX_GRAPH__GET_NUM_NODES)
    }
}

// OrtStatusPtr(* Graph_GetNodes)( const OrtGraph* graph, const OrtNode** nodes, size_t num_nodes) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_NODES: usize = 345;
pub type Graph_GetNodesFn = unsafe extern "C" fn(
    graph: *const GraphHandle,
    nodes: *const *const NodeHandle,
    num_nodes: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_nodes(&self) -> Graph_GetNodesFn {
        self.f(IDX_GRAPH__GET_NODES)
    }
}

// OrtStatusPtr(* Graph_GetParentNode)( const OrtGraph* graph, const OrtNode** node) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_PARENT_NODE: usize = 346;
pub type Graph_GetParentNodeFn =
    unsafe extern "C" fn(graph: *const GraphHandle, node: *const *const NodeHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_parent_node(&self) -> Graph_GetParentNodeFn {
        self.f(IDX_GRAPH__GET_PARENT_NODE)
    }
}

// OrtStatusPtr(* Graph_GetGraphView)( const OrtGraph* src_graph, const OrtNode** nodes, size_t num_nodes, OrtGraph** dst_graph) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_GRAPH_VIEW: usize = 347;
pub type Graph_GetGraphViewFn = unsafe extern "C" fn(
    src_graph: *const GraphHandle,
    nodes: *const *const NodeHandle,
    num_nodes: usize,
    dst_graph: *mut *mut GraphHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_graph_view(&self) -> Graph_GetGraphViewFn {
        self.f(IDX_GRAPH__GET_GRAPH_VIEW)
    }
}

// OrtStatusPtr(* Node_GetId)( const OrtNode* node, size_t* node_id) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_ID: usize = 348;
pub type Node_GetIdFn =
    unsafe extern "C" fn(node: *const NodeHandle, node_id: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_id(&self) -> Node_GetIdFn {
        self.f(IDX_NODE__GET_ID)
    }
}

// OrtStatusPtr(* Node_GetName)( const OrtNode* node, const char** node_name) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_NAME: usize = 349;
pub type Node_GetNameFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    node_name: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_name(&self) -> Node_GetNameFn {
        self.f(IDX_NODE__GET_NAME)
    }
}

// OrtStatusPtr(* Node_GetOperatorType)( const OrtNode* node, const char** operator_type) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_OPERATOR_TYPE: usize = 350;
pub type Node_GetOperatorTypeFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    operator_type: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_operator_type(&self) -> Node_GetOperatorTypeFn {
        self.f(IDX_NODE__GET_OPERATOR_TYPE)
    }
}

// OrtStatusPtr(* Node_GetDomain)( const OrtNode* node, const char** domain_name) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_DOMAIN: usize = 351;
pub type Node_GetDomainFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    domain_name: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_domain(&self) -> Node_GetDomainFn {
        self.f(IDX_NODE__GET_DOMAIN)
    }
}

// OrtStatusPtr(* Node_GetSinceVersion)( const OrtNode* node, int* since_version) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_SINCE_VERSION: usize = 352;
pub type Node_GetSinceVersionFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    since_version: *mut core::ffi::c_int,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_since_version(&self) -> Node_GetSinceVersionFn {
        self.f(IDX_NODE__GET_SINCE_VERSION)
    }
}

// OrtStatusPtr(* Node_GetNumInputs)( const OrtNode* node, size_t* num_inputs) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_NUM_INPUTS: usize = 353;
pub type Node_GetNumInputsFn =
    unsafe extern "C" fn(node: *const NodeHandle, num_inputs: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_num_inputs(&self) -> Node_GetNumInputsFn {
        self.f(IDX_NODE__GET_NUM_INPUTS)
    }
}

// OrtStatusPtr(* Node_GetInputs)( const OrtNode* node, const OrtValueInfo** inputs, size_t num_inputs) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_INPUTS: usize = 354;
pub type Node_GetInputsFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    inputs: *const *const ValueInfoHandle,
    num_inputs: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_inputs(&self) -> Node_GetInputsFn {
        self.f(IDX_NODE__GET_INPUTS)
    }
}

// OrtStatusPtr(* Node_GetNumOutputs)( const OrtNode* node, size_t* num_outputs) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_NUM_OUTPUTS: usize = 355;
pub type Node_GetNumOutputsFn =
    unsafe extern "C" fn(node: *const NodeHandle, num_outputs: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_num_outputs(&self) -> Node_GetNumOutputsFn {
        self.f(IDX_NODE__GET_NUM_OUTPUTS)
    }
}

// OrtStatusPtr(* Node_GetOutputs)( const OrtNode* node, const OrtValueInfo** outputs, size_t num_outputs) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_OUTPUTS: usize = 356;
pub type Node_GetOutputsFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    outputs: *const *const ValueInfoHandle,
    num_outputs: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_outputs(&self) -> Node_GetOutputsFn {
        self.f(IDX_NODE__GET_OUTPUTS)
    }
}

// OrtStatusPtr(* Node_GetNumImplicitInputs)( const OrtNode* node, size_t* num_implicit_inputs) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_NUM_IMPLICIT_INPUTS: usize = 357;
pub type Node_GetNumImplicitInputsFn =
    unsafe extern "C" fn(node: *const NodeHandle, num_implicit_inputs: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_num_implicit_inputs(&self) -> Node_GetNumImplicitInputsFn {
        self.f(IDX_NODE__GET_NUM_IMPLICIT_INPUTS)
    }
}

// OrtStatusPtr(* Node_GetImplicitInputs)( const OrtNode* node, const OrtValueInfo** implicit_inputs, size_t num_implicit_inputs) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_IMPLICIT_INPUTS: usize = 358;
pub type Node_GetImplicitInputsFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    implicit_inputs: *const *const ValueInfoHandle,
    num_implicit_inputs: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_implicit_inputs(&self) -> Node_GetImplicitInputsFn {
        self.f(IDX_NODE__GET_IMPLICIT_INPUTS)
    }
}

// OrtStatusPtr(* Node_GetNumAttributes)( const OrtNode* node, size_t* num_attributes) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_NUM_ATTRIBUTES: usize = 359;
pub type Node_GetNumAttributesFn =
    unsafe extern "C" fn(node: *const NodeHandle, num_attributes: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_num_attributes(&self) -> Node_GetNumAttributesFn {
        self.f(IDX_NODE__GET_NUM_ATTRIBUTES)
    }
}

// OrtStatusPtr(* Node_GetAttributes)( const OrtNode* node, const OrtOpAttr** attributes, size_t num_attributes) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_ATTRIBUTES: usize = 360;
pub type Node_GetAttributesFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    attributes: *const *const OpAttrHandle,
    num_attributes: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_attributes(&self) -> Node_GetAttributesFn {
        self.f(IDX_NODE__GET_ATTRIBUTES)
    }
}

// OrtStatusPtr(* Node_GetAttributeByName)( const OrtNode* node, const char* attribute_name, const OrtOpAttr** attribute) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_ATTRIBUTE_BY_NAME: usize = 361;
pub type Node_GetAttributeByNameFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    attribute_name: *const core::ffi::c_char,
    attribute: *const *const OpAttrHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_attribute_by_name(&self) -> Node_GetAttributeByNameFn {
        self.f(IDX_NODE__GET_ATTRIBUTE_BY_NAME)
    }
}

// OrtStatusPtr(* OpAttr_GetTensorAttributeAsOrtValue)( const OrtOpAttr* attribute, OrtValue** attr_tensor) __attribute__((warn_unused_result))
pub const IDX_OP_ATTR__GET_TENSOR_ATTRIBUTE_AS_ORT_VALUE: usize = 362;
pub type OpAttr_GetTensorAttributeAsOrtValueFn = unsafe extern "C" fn(
    attribute: *const OpAttrHandle,
    attr_tensor: *mut *mut ValueHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn op_attr__get_tensor_attribute_as_ort_value(
        &self,
    ) -> OpAttr_GetTensorAttributeAsOrtValueFn {
        self.f(IDX_OP_ATTR__GET_TENSOR_ATTRIBUTE_AS_ORT_VALUE)
    }
}

// OrtStatusPtr(* OpAttr_GetType)( const OrtOpAttr* attribute, OrtOpAttrType* type) __attribute__((warn_unused_result))
pub const IDX_OP_ATTR__GET_TYPE: usize = 363;
pub type OpAttr_GetTypeFn =
    unsafe extern "C" fn(attribute: *const OpAttrHandle, type_: *mut OpAttrType) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn op_attr__get_type(&self) -> OpAttr_GetTypeFn {
        self.f(IDX_OP_ATTR__GET_TYPE)
    }
}

// OrtStatusPtr(* OpAttr_GetName)( const OrtOpAttr* attribute, const char** name) __attribute__((warn_unused_result))
pub const IDX_OP_ATTR__GET_NAME: usize = 364;
pub type OpAttr_GetNameFn = unsafe extern "C" fn(
    attribute: *const OpAttrHandle,
    name: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn op_attr__get_name(&self) -> OpAttr_GetNameFn {
        self.f(IDX_OP_ATTR__GET_NAME)
    }
}

// OrtStatusPtr(* Node_GetNumSubgraphs)( const OrtNode* node, size_t* num_subgraphs) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_NUM_SUBGRAPHS: usize = 365;
pub type Node_GetNumSubgraphsFn =
    unsafe extern "C" fn(node: *const NodeHandle, num_subgraphs: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_num_subgraphs(&self) -> Node_GetNumSubgraphsFn {
        self.f(IDX_NODE__GET_NUM_SUBGRAPHS)
    }
}

// OrtStatusPtr(* Node_GetSubgraphs)( const OrtNode* node, const OrtGraph** subgraphs, size_t num_subgraphs, const char** attribute_names) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_SUBGRAPHS: usize = 366;
pub type Node_GetSubgraphsFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    subgraphs: *const *const GraphHandle,
    num_subgraphs: usize,
    attribute_names: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_subgraphs(&self) -> Node_GetSubgraphsFn {
        self.f(IDX_NODE__GET_SUBGRAPHS)
    }
}

// OrtStatusPtr(* Node_GetGraph)( const OrtNode* node, const OrtGraph** graph) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_GRAPH: usize = 367;
pub type Node_GetGraphFn =
    unsafe extern "C" fn(node: *const NodeHandle, graph: *const *const GraphHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_graph(&self) -> Node_GetGraphFn {
        self.f(IDX_NODE__GET_GRAPH)
    }
}

// OrtStatusPtr(* Node_GetEpName)( const OrtNode* node, const char** out) __attribute__((warn_unused_result))
pub const IDX_NODE__GET_EP_NAME: usize = 368;
pub type Node_GetEpNameFn = unsafe extern "C" fn(
    node: *const NodeHandle,
    out_: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn node__get_ep_name(&self) -> Node_GetEpNameFn {
        self.f(IDX_NODE__GET_EP_NAME)
    }
}

// void( * ReleaseExternalInitializerInfo)( OrtExternalInitializerInfo * input)
pub const IDX_RELEASE_EXTERNAL_INITIALIZER_INFO: usize = 369;
pub type ReleaseExternalInitializerInfoFn =
    unsafe extern "C" fn(input: *mut ExternalInitializerInfoHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_external_initializer_info(&self) -> ReleaseExternalInitializerInfoFn {
        self.f(IDX_RELEASE_EXTERNAL_INITIALIZER_INFO)
    }
}

// const char*(* ExternalInitializerInfo_GetFilePath)( const OrtExternalInitializerInfo* info)
pub const IDX_EXTERNAL_INITIALIZER_INFO__GET_FILE_PATH: usize = 370;
pub type ExternalInitializerInfo_GetFilePathFn =
    unsafe extern "C" fn(info: *const ExternalInitializerInfoHandle) -> *const core::ffi::c_char;
impl Api {
    #[inline]
    pub unsafe fn external_initializer_info__get_file_path(
        &self,
    ) -> ExternalInitializerInfo_GetFilePathFn {
        self.f(IDX_EXTERNAL_INITIALIZER_INFO__GET_FILE_PATH)
    }
}

// int64_t(* ExternalInitializerInfo_GetFileOffset)( const OrtExternalInitializerInfo* info)
pub const IDX_EXTERNAL_INITIALIZER_INFO__GET_FILE_OFFSET: usize = 371;
pub type ExternalInitializerInfo_GetFileOffsetFn =
    unsafe extern "C" fn(info: *const ExternalInitializerInfoHandle) -> i64;
impl Api {
    #[inline]
    pub unsafe fn external_initializer_info__get_file_offset(
        &self,
    ) -> ExternalInitializerInfo_GetFileOffsetFn {
        self.f(IDX_EXTERNAL_INITIALIZER_INFO__GET_FILE_OFFSET)
    }
}

// size_t(* ExternalInitializerInfo_GetByteSize)( const OrtExternalInitializerInfo* info)
pub const IDX_EXTERNAL_INITIALIZER_INFO__GET_BYTE_SIZE: usize = 372;
pub type ExternalInitializerInfo_GetByteSizeFn =
    unsafe extern "C" fn(info: *const ExternalInitializerInfoHandle) -> usize;
impl Api {
    #[inline]
    pub unsafe fn external_initializer_info__get_byte_size(
        &self,
    ) -> ExternalInitializerInfo_GetByteSizeFn {
        self.f(IDX_EXTERNAL_INITIALIZER_INFO__GET_BYTE_SIZE)
    }
}

// const char*(* GetRunConfigEntry)( const OrtRunOptions* options, const char* config_key)
pub const IDX_GET_RUN_CONFIG_ENTRY: usize = 373;
pub type GetRunConfigEntryFn = unsafe extern "C" fn(
    options: *const RunOptionsHandle,
    config_key: *const core::ffi::c_char,
) -> *const core::ffi::c_char;
impl Api {
    #[inline]
    pub unsafe fn get_run_config_entry(&self) -> GetRunConfigEntryFn {
        self.f(IDX_GET_RUN_CONFIG_ENTRY)
    }
}

// const OrtMemoryInfo*(* EpDevice_MemoryInfo)( const OrtEpDevice* ep_device, OrtDeviceMemoryType memory_type)
pub const IDX_EP_DEVICE__MEMORY_INFO: usize = 374;
pub type EpDevice_MemoryInfoFn = unsafe extern "C" fn(
    ep_device: *const EpDeviceHandle,
    memory_type: i32,
) -> *const MemoryInfoHandle;
impl Api {
    #[inline]
    pub unsafe fn ep_device__memory_info(&self) -> EpDevice_MemoryInfoFn {
        self.f(IDX_EP_DEVICE__MEMORY_INFO)
    }
}

// OrtStatusPtr(* CreateSharedAllocator)( OrtEnv* env, const OrtEpDevice* ep_device, OrtDeviceMemoryType mem_type, OrtAllocatorType allocator_type, const OrtKeyValuePairs* allocator_options, OrtAllocator** allocator) __attribute__((warn_unused_result))
pub const IDX_CREATE_SHARED_ALLOCATOR: usize = 375;
pub type CreateSharedAllocatorFn = unsafe extern "C" fn(
    env: *mut EnvHandle,
    ep_device: *const EpDeviceHandle,
    mem_type: i32,
    allocator_type: AllocatorType,
    allocator_options: *const KeyValuePairsHandle,
    allocator: *mut *mut AllocatorHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_shared_allocator(&self) -> CreateSharedAllocatorFn {
        self.f(IDX_CREATE_SHARED_ALLOCATOR)
    }
}

// OrtStatusPtr(* GetSharedAllocator)( OrtEnv* env, const OrtMemoryInfo* mem_info, OrtAllocator** allocator) __attribute__((warn_unused_result))
pub const IDX_GET_SHARED_ALLOCATOR: usize = 376;
pub type GetSharedAllocatorFn = unsafe extern "C" fn(
    env: *mut EnvHandle,
    mem_info: *const MemoryInfoHandle,
    allocator: *mut *mut AllocatorHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_shared_allocator(&self) -> GetSharedAllocatorFn {
        self.f(IDX_GET_SHARED_ALLOCATOR)
    }
}

// OrtStatusPtr(* ReleaseSharedAllocator)( OrtEnv* env, const OrtEpDevice* ep_device, OrtDeviceMemoryType mem_type) __attribute__((warn_unused_result))
pub const IDX_RELEASE_SHARED_ALLOCATOR: usize = 377;
pub type ReleaseSharedAllocatorFn = unsafe extern "C" fn(
    env: *mut EnvHandle,
    ep_device: *const EpDeviceHandle,
    mem_type: i32,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn release_shared_allocator(&self) -> ReleaseSharedAllocatorFn {
        self.f(IDX_RELEASE_SHARED_ALLOCATOR)
    }
}

// OrtStatusPtr(* GetTensorData)( const OrtValue* value, const void** out) __attribute__((warn_unused_result))
pub const IDX_GET_TENSOR_DATA: usize = 378;
pub type GetTensorDataFn = unsafe extern "C" fn(
    value: *const ValueHandle,
    out_: *const *const core::ffi::c_void,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_tensor_data(&self) -> GetTensorDataFn {
        self.f(IDX_GET_TENSOR_DATA)
    }
}

// OrtStatusPtr(* GetSessionOptionsConfigEntries)( const OrtSessionOptions* options, OrtKeyValuePairs** out) __attribute__((warn_unused_result))
pub const IDX_GET_SESSION_OPTIONS_CONFIG_ENTRIES: usize = 379;
pub type GetSessionOptionsConfigEntriesFn = unsafe extern "C" fn(
    options: *const SessionOptionsHandle,
    out_: *mut *mut KeyValuePairsHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_session_options_config_entries(&self) -> GetSessionOptionsConfigEntriesFn {
        self.f(IDX_GET_SESSION_OPTIONS_CONFIG_ENTRIES)
    }
}

// OrtStatusPtr(* SessionGetMemoryInfoForInputs)( const OrtSession* session, const OrtMemoryInfo** inputs_memory_info, size_t num_inputs) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_MEMORY_INFO_FOR_INPUTS: usize = 380;
pub type SessionGetMemoryInfoForInputsFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    inputs_memory_info: *const *const MemoryInfoHandle,
    num_inputs: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_memory_info_for_inputs(&self) -> SessionGetMemoryInfoForInputsFn {
        self.f(IDX_SESSION_GET_MEMORY_INFO_FOR_INPUTS)
    }
}

// OrtStatusPtr(* SessionGetMemoryInfoForOutputs)( const OrtSession* session, const OrtMemoryInfo** outputs_memory_info, size_t num_outputs) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_MEMORY_INFO_FOR_OUTPUTS: usize = 381;
pub type SessionGetMemoryInfoForOutputsFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    outputs_memory_info: *const *const MemoryInfoHandle,
    num_outputs: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_memory_info_for_outputs(&self) -> SessionGetMemoryInfoForOutputsFn {
        self.f(IDX_SESSION_GET_MEMORY_INFO_FOR_OUTPUTS)
    }
}

// OrtStatusPtr(* SessionGetEpDeviceForInputs)( const OrtSession* session, const OrtEpDevice** inputs_ep_devices, size_t num_inputs) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_EP_DEVICE_FOR_INPUTS: usize = 382;
pub type SessionGetEpDeviceForInputsFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    inputs_ep_devices: *const *const EpDeviceHandle,
    num_inputs: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_ep_device_for_inputs(&self) -> SessionGetEpDeviceForInputsFn {
        self.f(IDX_SESSION_GET_EP_DEVICE_FOR_INPUTS)
    }
}

// OrtStatusPtr(* CreateSyncStreamForEpDevice)( const OrtEpDevice* ep_device, const OrtKeyValuePairs* stream_options, OrtSyncStream** stream) __attribute__((warn_unused_result))
pub const IDX_CREATE_SYNC_STREAM_FOR_EP_DEVICE: usize = 383;
pub type CreateSyncStreamForEpDeviceFn = unsafe extern "C" fn(
    ep_device: *const EpDeviceHandle,
    stream_options: *const KeyValuePairsHandle,
    stream: *mut *mut SyncStreamHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_sync_stream_for_ep_device(&self) -> CreateSyncStreamForEpDeviceFn {
        self.f(IDX_CREATE_SYNC_STREAM_FOR_EP_DEVICE)
    }
}

// void*(* SyncStream_GetHandle)( OrtSyncStream* stream)
pub const IDX_SYNC_STREAM__GET_HANDLE: usize = 384;
pub type SyncStream_GetHandleFn =
    unsafe extern "C" fn(stream: *mut SyncStreamHandle) -> *mut core::ffi::c_void;
impl Api {
    #[inline]
    pub unsafe fn sync_stream__get_handle(&self) -> SyncStream_GetHandleFn {
        self.f(IDX_SYNC_STREAM__GET_HANDLE)
    }
}

// void( * ReleaseSyncStream)( OrtSyncStream * input)
pub const IDX_RELEASE_SYNC_STREAM: usize = 385;
pub type ReleaseSyncStreamFn = unsafe extern "C" fn(input: *mut SyncStreamHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_sync_stream(&self) -> ReleaseSyncStreamFn {
        self.f(IDX_RELEASE_SYNC_STREAM)
    }
}

// OrtStatusPtr(* CopyTensors)( const OrtEnv* env, const OrtValue* const* src_tensors, OrtValue* const* dst_tensors, OrtSyncStream* stream, size_t num_tensors) __attribute__((warn_unused_result))
pub const IDX_COPY_TENSORS: usize = 386;
pub type CopyTensorsFn = unsafe extern "C" fn(
    env: *const EnvHandle,
    src_tensors: *const *const ValueHandle,
    dst_tensors: *mut *mut ValueHandle,
    stream: *mut SyncStreamHandle,
    num_tensors: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn copy_tensors(&self) -> CopyTensorsFn {
        self.f(IDX_COPY_TENSORS)
    }
}

// OrtStatusPtr(* Graph_GetModelMetadata)( const OrtGraph* graph, OrtModelMetadata** out) __attribute__((warn_unused_result))
pub const IDX_GRAPH__GET_MODEL_METADATA: usize = 387;
pub type Graph_GetModelMetadataFn = unsafe extern "C" fn(
    graph: *const GraphHandle,
    out_: *mut *mut ModelMetadataHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn graph__get_model_metadata(&self) -> Graph_GetModelMetadataFn {
        self.f(IDX_GRAPH__GET_MODEL_METADATA)
    }
}

// OrtStatusPtr(* GetModelCompatibilityForEpDevices)( const OrtEpDevice* const* ep_devices, size_t num_ep_devices, const char* compatibility_info, OrtCompiledModelCompatibility* out_status) __attribute__((warn_unused_result))
pub const IDX_GET_MODEL_COMPATIBILITY_FOR_EP_DEVICES: usize = 388;
pub type GetModelCompatibilityForEpDevicesFn = unsafe extern "C" fn(
    ep_devices: *const *const EpDeviceHandle,
    num_ep_devices: usize,
    compatibility_info: *const core::ffi::c_char,
    out_status: *mut CompiledModelCompatibilityHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_model_compatibility_for_ep_devices(
        &self,
    ) -> GetModelCompatibilityForEpDevicesFn {
        self.f(IDX_GET_MODEL_COMPATIBILITY_FOR_EP_DEVICES)
    }
}

// OrtStatusPtr(* CreateExternalInitializerInfo)( const char* filepath, int64_t file_offset, size_t byte_size, OrtExternalInitializerInfo** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_EXTERNAL_INITIALIZER_INFO: usize = 389;
pub type CreateExternalInitializerInfoFn = unsafe extern "C" fn(
    filepath: *const core::ffi::c_char,
    file_offset: i64,
    byte_size: usize,
    out_: *mut *mut ExternalInitializerInfoHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_external_initializer_info(&self) -> CreateExternalInitializerInfoFn {
        self.f(IDX_CREATE_EXTERNAL_INITIALIZER_INFO)
    }
}

// bool(* TensorTypeAndShape_HasShape)( const OrtTensorTypeAndShapeInfo* info)
pub const IDX_TENSOR_TYPE_AND_SHAPE__HAS_SHAPE: usize = 390;
pub type TensorTypeAndShape_HasShapeFn =
    unsafe extern "C" fn(info: *const TensorTypeAndShapeInfoHandle) -> bool;
impl Api {
    #[inline]
    pub unsafe fn tensor_type_and_shape__has_shape(&self) -> TensorTypeAndShape_HasShapeFn {
        self.f(IDX_TENSOR_TYPE_AND_SHAPE__HAS_SHAPE)
    }
}

// OrtStatusPtr(* SessionGetEpDeviceForOutputs)( const OrtSession* session, const OrtEpDevice** outputs_ep_devices, size_t num_outputs) __attribute__((warn_unused_result))
pub const IDX_SESSION_GET_EP_DEVICE_FOR_OUTPUTS: usize = 396;
pub type SessionGetEpDeviceForOutputsFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    outputs_ep_devices: *const *const EpDeviceHandle,
    num_outputs: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session_get_ep_device_for_outputs(&self) -> SessionGetEpDeviceForOutputsFn {
        self.f(IDX_SESSION_GET_EP_DEVICE_FOR_OUTPUTS)
    }
}

// OrtStatusPtr(* GetNumHardwareDevices)( const OrtEnv* env, size_t* num_devices) __attribute__((warn_unused_result))
pub const IDX_GET_NUM_HARDWARE_DEVICES: usize = 397;
pub type GetNumHardwareDevicesFn =
    unsafe extern "C" fn(env: *const EnvHandle, num_devices: *mut usize) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_num_hardware_devices(&self) -> GetNumHardwareDevicesFn {
        self.f(IDX_GET_NUM_HARDWARE_DEVICES)
    }
}

// OrtStatusPtr(* GetHardwareDevices)( const OrtEnv* env, const OrtHardwareDevice** devices, size_t num_devices) __attribute__((warn_unused_result))
pub const IDX_GET_HARDWARE_DEVICES: usize = 398;
pub type GetHardwareDevicesFn = unsafe extern "C" fn(
    env: *const EnvHandle,
    devices: *const *const HardwareDeviceHandle,
    num_devices: usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_hardware_devices(&self) -> GetHardwareDevicesFn {
        self.f(IDX_GET_HARDWARE_DEVICES)
    }
}

// OrtStatusPtr(* GetHardwareDeviceEpIncompatibilityDetails)( const OrtEnv* env, const char* ep_name, const OrtHardwareDevice* hw, OrtDeviceEpIncompatibilityDetails** details) __attribute__((warn_unused_result))
pub const IDX_GET_HARDWARE_DEVICE_EP_INCOMPATIBILITY_DETAILS: usize = 399;
pub type GetHardwareDeviceEpIncompatibilityDetailsFn = unsafe extern "C" fn(
    env: *const EnvHandle,
    ep_name: *const core::ffi::c_char,
    hw: *const HardwareDeviceHandle,
    details: *mut *mut DeviceEpIncompatibilityDetailsHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_hardware_device_ep_incompatibility_details(
        &self,
    ) -> GetHardwareDeviceEpIncompatibilityDetailsFn {
        self.f(IDX_GET_HARDWARE_DEVICE_EP_INCOMPATIBILITY_DETAILS)
    }
}

// OrtStatusPtr(* DeviceEpIncompatibilityDetails_GetReasonsBitmask)( const OrtDeviceEpIncompatibilityDetails* details, uint32_t* reasons_bitmask) __attribute__((warn_unused_result))
pub const IDX_DEVICE_EP_INCOMPATIBILITY_DETAILS__GET_REASONS_BITMASK: usize = 400;
pub type DeviceEpIncompatibilityDetails_GetReasonsBitmaskFn = unsafe extern "C" fn(
    details: *const DeviceEpIncompatibilityDetailsHandle,
    reasons_bitmask: *mut u32,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn device_ep_incompatibility_details__get_reasons_bitmask(
        &self,
    ) -> DeviceEpIncompatibilityDetails_GetReasonsBitmaskFn {
        self.f(IDX_DEVICE_EP_INCOMPATIBILITY_DETAILS__GET_REASONS_BITMASK)
    }
}

// OrtStatusPtr(* DeviceEpIncompatibilityDetails_GetNotes)( const OrtDeviceEpIncompatibilityDetails* details, const char** notes) __attribute__((warn_unused_result))
pub const IDX_DEVICE_EP_INCOMPATIBILITY_DETAILS__GET_NOTES: usize = 401;
pub type DeviceEpIncompatibilityDetails_GetNotesFn = unsafe extern "C" fn(
    details: *const DeviceEpIncompatibilityDetailsHandle,
    notes: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn device_ep_incompatibility_details__get_notes(
        &self,
    ) -> DeviceEpIncompatibilityDetails_GetNotesFn {
        self.f(IDX_DEVICE_EP_INCOMPATIBILITY_DETAILS__GET_NOTES)
    }
}

// OrtStatusPtr(* DeviceEpIncompatibilityDetails_GetErrorCode)( const OrtDeviceEpIncompatibilityDetails* details, int32_t* error_code) __attribute__((warn_unused_result))
pub const IDX_DEVICE_EP_INCOMPATIBILITY_DETAILS__GET_ERROR_CODE: usize = 402;
pub type DeviceEpIncompatibilityDetails_GetErrorCodeFn = unsafe extern "C" fn(
    details: *const DeviceEpIncompatibilityDetailsHandle,
    error_code: *mut i32,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn device_ep_incompatibility_details__get_error_code(
        &self,
    ) -> DeviceEpIncompatibilityDetails_GetErrorCodeFn {
        self.f(IDX_DEVICE_EP_INCOMPATIBILITY_DETAILS__GET_ERROR_CODE)
    }
}

// void( * ReleaseDeviceEpIncompatibilityDetails)( OrtDeviceEpIncompatibilityDetails * input)
pub const IDX_RELEASE_DEVICE_EP_INCOMPATIBILITY_DETAILS: usize = 403;
pub type ReleaseDeviceEpIncompatibilityDetailsFn =
    unsafe extern "C" fn(input: *mut DeviceEpIncompatibilityDetailsHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn release_device_ep_incompatibility_details(
        &self,
    ) -> ReleaseDeviceEpIncompatibilityDetailsFn {
        self.f(IDX_RELEASE_DEVICE_EP_INCOMPATIBILITY_DETAILS)
    }
}

// OrtStatusPtr(* GetCompatibilityInfoFromModel)( const char* model_path, const char* ep_type, OrtAllocator* allocator, char** compatibility_info) __attribute__((warn_unused_result))
pub const IDX_GET_COMPATIBILITY_INFO_FROM_MODEL: usize = 404;
pub type GetCompatibilityInfoFromModelFn = unsafe extern "C" fn(
    model_path: *const core::ffi::c_char,
    ep_type: *const core::ffi::c_char,
    allocator: *mut AllocatorHandle,
    compatibility_info: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_compatibility_info_from_model(&self) -> GetCompatibilityInfoFromModelFn {
        self.f(IDX_GET_COMPATIBILITY_INFO_FROM_MODEL)
    }
}

// OrtStatusPtr(* GetCompatibilityInfoFromModelBytes)( const void* model_data, size_t model_data_length, const char* ep_type, OrtAllocator* allocator, char** compatibility_info) __attribute__((warn_unused_result))
pub const IDX_GET_COMPATIBILITY_INFO_FROM_MODEL_BYTES: usize = 405;
pub type GetCompatibilityInfoFromModelBytesFn = unsafe extern "C" fn(
    model_data: *const core::ffi::c_void,
    model_data_length: usize,
    ep_type: *const core::ffi::c_char,
    allocator: *mut AllocatorHandle,
    compatibility_info: *mut *mut core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_compatibility_info_from_model_bytes(
        &self,
    ) -> GetCompatibilityInfoFromModelBytesFn {
        self.f(IDX_GET_COMPATIBILITY_INFO_FROM_MODEL_BYTES)
    }
}

// OrtStatusPtr(* CreateEnvWithOptions)( const OrtEnvCreationOptions* options, OrtEnv** out) __attribute__((warn_unused_result))
pub const IDX_CREATE_ENV_WITH_OPTIONS: usize = 406;
pub type CreateEnvWithOptionsFn = unsafe extern "C" fn(
    options: *const EnvCreationOptionsHandle,
    out_: *mut *mut EnvHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn create_env_with_options(&self) -> CreateEnvWithOptionsFn {
        self.f(IDX_CREATE_ENV_WITH_OPTIONS)
    }
}

// OrtStatusPtr(* Session_GetEpGraphAssignmentInfo)( const OrtSession* session, const OrtEpAssignedSubgraph* const** ep_subgraphs, size_t* num_ep_subgraphs) __attribute__((warn_unused_result))
pub const IDX_SESSION__GET_EP_GRAPH_ASSIGNMENT_INFO: usize = 407;
pub type Session_GetEpGraphAssignmentInfoFn = unsafe extern "C" fn(
    session: *const SessionHandle,
    ep_subgraphs: *const *const *const EpAssignedSubgraphHandle,
    num_ep_subgraphs: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn session__get_ep_graph_assignment_info(
        &self,
    ) -> Session_GetEpGraphAssignmentInfoFn {
        self.f(IDX_SESSION__GET_EP_GRAPH_ASSIGNMENT_INFO)
    }
}

// OrtStatusPtr(* EpAssignedSubgraph_GetEpName)( const OrtEpAssignedSubgraph* ep_subgraph, const char** out) __attribute__((warn_unused_result))
pub const IDX_EP_ASSIGNED_SUBGRAPH__GET_EP_NAME: usize = 408;
pub type EpAssignedSubgraph_GetEpNameFn = unsafe extern "C" fn(
    ep_subgraph: *const EpAssignedSubgraphHandle,
    out_: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn ep_assigned_subgraph__get_ep_name(&self) -> EpAssignedSubgraph_GetEpNameFn {
        self.f(IDX_EP_ASSIGNED_SUBGRAPH__GET_EP_NAME)
    }
}

// OrtStatusPtr(* EpAssignedSubgraph_GetNodes)( const OrtEpAssignedSubgraph* ep_subgraph, const OrtEpAssignedNode* const** ep_nodes, size_t* num_ep_nodes) __attribute__((warn_unused_result))
pub const IDX_EP_ASSIGNED_SUBGRAPH__GET_NODES: usize = 409;
pub type EpAssignedSubgraph_GetNodesFn = unsafe extern "C" fn(
    ep_subgraph: *const EpAssignedSubgraphHandle,
    ep_nodes: *const *const *const EpAssignedNodeHandle,
    num_ep_nodes: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn ep_assigned_subgraph__get_nodes(&self) -> EpAssignedSubgraph_GetNodesFn {
        self.f(IDX_EP_ASSIGNED_SUBGRAPH__GET_NODES)
    }
}

// OrtStatusPtr(* EpAssignedNode_GetName)( const OrtEpAssignedNode* ep_node, const char** out) __attribute__((warn_unused_result))
pub const IDX_EP_ASSIGNED_NODE__GET_NAME: usize = 410;
pub type EpAssignedNode_GetNameFn = unsafe extern "C" fn(
    ep_node: *const EpAssignedNodeHandle,
    out_: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn ep_assigned_node__get_name(&self) -> EpAssignedNode_GetNameFn {
        self.f(IDX_EP_ASSIGNED_NODE__GET_NAME)
    }
}

// OrtStatusPtr(* EpAssignedNode_GetDomain)( const OrtEpAssignedNode* ep_node, const char** out) __attribute__((warn_unused_result))
pub const IDX_EP_ASSIGNED_NODE__GET_DOMAIN: usize = 411;
pub type EpAssignedNode_GetDomainFn = unsafe extern "C" fn(
    ep_node: *const EpAssignedNodeHandle,
    out_: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn ep_assigned_node__get_domain(&self) -> EpAssignedNode_GetDomainFn {
        self.f(IDX_EP_ASSIGNED_NODE__GET_DOMAIN)
    }
}

// OrtStatusPtr(* EpAssignedNode_GetOperatorType)( const OrtEpAssignedNode* ep_node, const char** out) __attribute__((warn_unused_result))
pub const IDX_EP_ASSIGNED_NODE__GET_OPERATOR_TYPE: usize = 412;
pub type EpAssignedNode_GetOperatorTypeFn = unsafe extern "C" fn(
    ep_node: *const EpAssignedNodeHandle,
    out_: *const *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn ep_assigned_node__get_operator_type(&self) -> EpAssignedNode_GetOperatorTypeFn {
        self.f(IDX_EP_ASSIGNED_NODE__GET_OPERATOR_TYPE)
    }
}

// void(* RunOptionsSetSyncStream)( OrtRunOptions* options, OrtSyncStream* sync_stream)
pub const IDX_RUN_OPTIONS_SET_SYNC_STREAM: usize = 413;
pub type RunOptionsSetSyncStreamFn =
    unsafe extern "C" fn(options: *mut RunOptionsHandle, sync_stream: *mut SyncStreamHandle) -> ();
impl Api {
    #[inline]
    pub unsafe fn run_options_set_sync_stream(&self) -> RunOptionsSetSyncStreamFn {
        self.f(IDX_RUN_OPTIONS_SET_SYNC_STREAM)
    }
}

// OrtStatusPtr(* GetTensorElementTypeAndShapeDataReference)( const OrtValue* value, ONNXTensorElementDataType* elem_type, const int64_t** shape_data, size_t* shape_data_count) __attribute__((warn_unused_result))
pub const IDX_GET_TENSOR_ELEMENT_TYPE_AND_SHAPE_DATA_REFERENCE: usize = 414;
pub type GetTensorElementTypeAndShapeDataReferenceFn = unsafe extern "C" fn(
    value: *const ValueHandle,
    elem_type: *mut ElementType,
    shape_data: *const *const i64,
    shape_data_count: *mut usize,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn get_tensor_element_type_and_shape_data_reference(
        &self,
    ) -> GetTensorElementTypeAndShapeDataReferenceFn {
        self.f(IDX_GET_TENSOR_ELEMENT_TYPE_AND_SHAPE_DATA_REFERENCE)
    }
}

// OrtStatusPtr(* RunOptionsEnableProfiling)( OrtRunOptions* options, const char* profile_file_prefix) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_ENABLE_PROFILING: usize = 415;
pub type RunOptionsEnableProfilingFn = unsafe extern "C" fn(
    options: *mut RunOptionsHandle,
    profile_file_prefix: *const core::ffi::c_char,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_enable_profiling(&self) -> RunOptionsEnableProfilingFn {
        self.f(IDX_RUN_OPTIONS_ENABLE_PROFILING)
    }
}

// OrtStatusPtr(* RunOptionsDisableProfiling)( OrtRunOptions* options) __attribute__((warn_unused_result))
pub const IDX_RUN_OPTIONS_DISABLE_PROFILING: usize = 416;
pub type RunOptionsDisableProfilingFn =
    unsafe extern "C" fn(options: *mut RunOptionsHandle) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn run_options_disable_profiling(&self) -> RunOptionsDisableProfilingFn {
        self.f(IDX_RUN_OPTIONS_DISABLE_PROFILING)
    }
}

// OrtStatusPtr(* SetPerSessionThreadPoolCallbacks)( OrtEnv* env, const OrtThreadPoolCallbacksConfig* config) __attribute__((warn_unused_result))
pub const IDX_SET_PER_SESSION_THREAD_POOL_CALLBACKS: usize = 418;
pub type SetPerSessionThreadPoolCallbacksFn = unsafe extern "C" fn(
    env: *mut EnvHandle,
    config: *const ThreadPoolCallbacksConfigHandle,
) -> StatusPtr;
impl Api {
    #[inline]
    pub unsafe fn set_per_session_thread_pool_callbacks(
        &self,
    ) -> SetPerSessionThreadPoolCallbacksFn {
        self.f(IDX_SET_PER_SESSION_THREAD_POOL_CALLBACKS)
    }
}

// ── Custom-op kernel authoring ────────────────────────────────────────────────────────────────
// OrtStatusPtr(* CustomOpDomain_Add)( OrtCustomOpDomain* custom_op_domain, const OrtCustomOp* op) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_CUSTOM_OP_DOMAIN__ADD: usize = 27;
#[cfg(feature = "custom-ops")]
pub type CustomOpDomain_AddFn = unsafe extern "C" fn(
    custom_op_domain: *mut CustomOpDomainHandle,
    op: *const CustomOpHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn custom_op_domain__add(&self) -> CustomOpDomain_AddFn {
        self.f(IDX_CUSTOM_OP_DOMAIN__ADD)
    }
}

// OrtStatusPtr(* KernelInfoGetAttribute_float)( const OrtKernelInfo* info, const char* name, float* out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO_GET_ATTRIBUTE_FLOAT: usize = 85;
#[cfg(feature = "custom-ops")]
pub type KernelInfoGetAttribute_floatFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    name: *const core::ffi::c_char,
    out_: *mut f32,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info_get_attribute_float(&self) -> KernelInfoGetAttribute_floatFn {
        self.f(IDX_KERNEL_INFO_GET_ATTRIBUTE_FLOAT)
    }
}

// OrtStatusPtr(* KernelInfoGetAttribute_int64)( const OrtKernelInfo* info, const char* name, int64_t* out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO_GET_ATTRIBUTE_INT64: usize = 86;
#[cfg(feature = "custom-ops")]
pub type KernelInfoGetAttribute_int64Fn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    name: *const core::ffi::c_char,
    out_: *mut i64,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info_get_attribute_int64(&self) -> KernelInfoGetAttribute_int64Fn {
        self.f(IDX_KERNEL_INFO_GET_ATTRIBUTE_INT64)
    }
}

// OrtStatusPtr(* KernelInfoGetAttribute_string)( const OrtKernelInfo* info, const char* name, char* out, size_t* size) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO_GET_ATTRIBUTE_STRING: usize = 87;
#[cfg(feature = "custom-ops")]
pub type KernelInfoGetAttribute_stringFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    name: *const core::ffi::c_char,
    out_: *mut core::ffi::c_char,
    size: *mut usize,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info_get_attribute_string(&self) -> KernelInfoGetAttribute_stringFn {
        self.f(IDX_KERNEL_INFO_GET_ATTRIBUTE_STRING)
    }
}

// OrtStatusPtr(* KernelContext_GetInputCount)( const OrtKernelContext* context, size_t* out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_CONTEXT__GET_INPUT_COUNT: usize = 88;
#[cfg(feature = "custom-ops")]
pub type KernelContext_GetInputCountFn =
    unsafe extern "C" fn(context: *const KernelContextHandle, out_: *mut usize) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_context__get_input_count(&self) -> KernelContext_GetInputCountFn {
        self.f(IDX_KERNEL_CONTEXT__GET_INPUT_COUNT)
    }
}

// OrtStatusPtr(* KernelContext_GetOutputCount)( const OrtKernelContext* context, size_t* out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_CONTEXT__GET_OUTPUT_COUNT: usize = 89;
#[cfg(feature = "custom-ops")]
pub type KernelContext_GetOutputCountFn =
    unsafe extern "C" fn(context: *const KernelContextHandle, out_: *mut usize) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_context__get_output_count(&self) -> KernelContext_GetOutputCountFn {
        self.f(IDX_KERNEL_CONTEXT__GET_OUTPUT_COUNT)
    }
}

// OrtStatusPtr(* KernelContext_GetInput)( const OrtKernelContext* context, size_t index, const OrtValue** out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_CONTEXT__GET_INPUT: usize = 90;
#[cfg(feature = "custom-ops")]
pub type KernelContext_GetInputFn = unsafe extern "C" fn(
    context: *const KernelContextHandle,
    index: usize,
    out_: *const *const ValueHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_context__get_input(&self) -> KernelContext_GetInputFn {
        self.f(IDX_KERNEL_CONTEXT__GET_INPUT)
    }
}

// OrtStatusPtr(* KernelContext_GetOutput)( OrtKernelContext* context, size_t index, const int64_t* dim_values, size_t dim_count, OrtValue** out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_CONTEXT__GET_OUTPUT: usize = 91;
#[cfg(feature = "custom-ops")]
pub type KernelContext_GetOutputFn = unsafe extern "C" fn(
    context: *mut KernelContextHandle,
    index: usize,
    dim_values: *const i64,
    dim_count: usize,
    out_: *mut *mut ValueHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_context__get_output(&self) -> KernelContext_GetOutputFn {
        self.f(IDX_KERNEL_CONTEXT__GET_OUTPUT)
    }
}

// OrtStatusPtr(* KernelInfoGetAttributeArray_float)( const OrtKernelInfo* info, const char* name, float* out, size_t* size) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO_GET_ATTRIBUTE_ARRAY_FLOAT: usize = 162;
#[cfg(feature = "custom-ops")]
pub type KernelInfoGetAttributeArray_floatFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    name: *const core::ffi::c_char,
    out_: *mut f32,
    size: *mut usize,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info_get_attribute_array_float(
        &self,
    ) -> KernelInfoGetAttributeArray_floatFn {
        self.f(IDX_KERNEL_INFO_GET_ATTRIBUTE_ARRAY_FLOAT)
    }
}

// OrtStatusPtr(* KernelInfoGetAttributeArray_int64)( const OrtKernelInfo* info, const char* name, int64_t* out, size_t* size) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO_GET_ATTRIBUTE_ARRAY_INT64: usize = 163;
#[cfg(feature = "custom-ops")]
pub type KernelInfoGetAttributeArray_int64Fn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    name: *const core::ffi::c_char,
    out_: *mut i64,
    size: *mut usize,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info_get_attribute_array_int64(
        &self,
    ) -> KernelInfoGetAttributeArray_int64Fn {
        self.f(IDX_KERNEL_INFO_GET_ATTRIBUTE_ARRAY_INT64)
    }
}

// OrtStatusPtr(* KernelContext_GetGPUComputeStream)( const OrtKernelContext* context, void** out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_CONTEXT__GET_GPU_COMPUTE_STREAM: usize = 193;
#[cfg(feature = "custom-ops")]
pub type KernelContext_GetGpuComputeStreamFn = unsafe extern "C" fn(
    context: *const KernelContextHandle,
    out_: *mut *mut core::ffi::c_void,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_context__get_gpu_compute_stream(
        &self,
    ) -> KernelContext_GetGpuComputeStreamFn {
        self.f(IDX_KERNEL_CONTEXT__GET_GPU_COMPUTE_STREAM)
    }
}

// void( * ReleaseOpAttr)( OrtOpAttr * input)
#[cfg(any(feature = "custom-ops", feature = "model-editor"))]
pub const IDX_RELEASE_OP_ATTR: usize = 212;
#[cfg(any(feature = "custom-ops", feature = "model-editor"))]
pub type ReleaseOpAttrFn = unsafe extern "C" fn(input: *mut OpAttrHandle) -> ();
#[cfg(any(feature = "custom-ops", feature = "model-editor"))]
impl Api {
    #[inline]
    #[cfg(any(feature = "custom-ops", feature = "model-editor"))]
    pub unsafe fn release_op_attr(&self) -> ReleaseOpAttrFn {
        self.f(IDX_RELEASE_OP_ATTR)
    }
}

// OrtStatusPtr(* CreateOp)( const OrtKernelInfo* info, const char* op_name, const char* domain, int version, const char** type_constraint_names, const ONNXTensorElementDataType* type_constraint_values, int type_constraint_count, const OrtOpAttr* const* attr_values, int attr_count, int input_count, int output_count, OrtOp** ort_op) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_CREATE_OP: usize = 213;
#[cfg(feature = "custom-ops")]
pub type CreateOpFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    op_name: *const core::ffi::c_char,
    domain: *const core::ffi::c_char,
    version: core::ffi::c_int,
    type_constraint_names: *const *const core::ffi::c_char,
    type_constraint_values: *const ElementType,
    type_constraint_count: core::ffi::c_int,
    attr_values: *const *const OpAttrHandle,
    attr_count: core::ffi::c_int,
    input_count: core::ffi::c_int,
    output_count: core::ffi::c_int,
    ort_op: *mut *mut OpHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn create_op(&self) -> CreateOpFn {
        self.f(IDX_CREATE_OP)
    }
}

// void( * ReleaseOp)( OrtOp * input)
#[cfg(feature = "custom-ops")]
pub const IDX_RELEASE_OP: usize = 215;
#[cfg(feature = "custom-ops")]
pub type ReleaseOpFn = unsafe extern "C" fn(input: *mut OpHandle) -> ();
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn release_op(&self) -> ReleaseOpFn {
        self.f(IDX_RELEASE_OP)
    }
}

// void( * ReleaseKernelInfo)( OrtKernelInfo * input)
#[cfg(feature = "custom-ops")]
pub const IDX_RELEASE_KERNEL_INFO: usize = 218;
#[cfg(feature = "custom-ops")]
pub type ReleaseKernelInfoFn = unsafe extern "C" fn(input: *mut KernelInfoHandle) -> ();
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn release_kernel_info(&self) -> ReleaseKernelInfoFn {
        self.f(IDX_RELEASE_KERNEL_INFO)
    }
}

// OrtStatusPtr(* KernelInfo_GetInputCount)( const OrtKernelInfo* info, size_t* out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_INPUT_COUNT: usize = 230;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetInputCountFn =
    unsafe extern "C" fn(info: *const KernelInfoHandle, out_: *mut usize) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_input_count(&self) -> KernelInfo_GetInputCountFn {
        self.f(IDX_KERNEL_INFO__GET_INPUT_COUNT)
    }
}

// OrtStatusPtr(* KernelInfo_GetOutputCount)( const OrtKernelInfo* info, size_t* out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_OUTPUT_COUNT: usize = 231;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetOutputCountFn =
    unsafe extern "C" fn(info: *const KernelInfoHandle, out_: *mut usize) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_output_count(&self) -> KernelInfo_GetOutputCountFn {
        self.f(IDX_KERNEL_INFO__GET_OUTPUT_COUNT)
    }
}

// OrtStatusPtr(* KernelInfo_GetInputName)( const OrtKernelInfo* info, size_t index, char* out, size_t* size) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_INPUT_NAME: usize = 232;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetInputNameFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    index: usize,
    out_: *mut core::ffi::c_char,
    size: *mut usize,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_input_name(&self) -> KernelInfo_GetInputNameFn {
        self.f(IDX_KERNEL_INFO__GET_INPUT_NAME)
    }
}

// OrtStatusPtr(* KernelInfo_GetOutputName)( const OrtKernelInfo* info, size_t index, char* out, size_t* size) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_OUTPUT_NAME: usize = 233;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetOutputNameFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    index: usize,
    out_: *mut core::ffi::c_char,
    size: *mut usize,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_output_name(&self) -> KernelInfo_GetOutputNameFn {
        self.f(IDX_KERNEL_INFO__GET_OUTPUT_NAME)
    }
}

// OrtStatusPtr(* KernelInfo_GetInputTypeInfo)( const OrtKernelInfo* info, size_t index, OrtTypeInfo** type_info) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_INPUT_TYPE_INFO: usize = 234;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetInputTypeInfoFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    index: usize,
    type_info: *mut *mut TypeInfoHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_input_type_info(&self) -> KernelInfo_GetInputTypeInfoFn {
        self.f(IDX_KERNEL_INFO__GET_INPUT_TYPE_INFO)
    }
}

// OrtStatusPtr(* KernelInfo_GetOutputTypeInfo)( const OrtKernelInfo* info, size_t index, OrtTypeInfo** type_info) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_OUTPUT_TYPE_INFO: usize = 235;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetOutputTypeInfoFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    index: usize,
    type_info: *mut *mut TypeInfoHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_output_type_info(&self) -> KernelInfo_GetOutputTypeInfoFn {
        self.f(IDX_KERNEL_INFO__GET_OUTPUT_TYPE_INFO)
    }
}

// OrtStatusPtr(* KernelInfoGetAttribute_tensor)( const OrtKernelInfo* info, const char* name, OrtAllocator* allocator, OrtValue** out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO_GET_ATTRIBUTE_TENSOR: usize = 236;
#[cfg(feature = "custom-ops")]
pub type KernelInfoGetAttribute_tensorFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    name: *const core::ffi::c_char,
    allocator: *mut AllocatorHandle,
    out_: *mut *mut ValueHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info_get_attribute_tensor(&self) -> KernelInfoGetAttribute_tensorFn {
        self.f(IDX_KERNEL_INFO_GET_ATTRIBUTE_TENSOR)
    }
}

// OrtStatusPtr(* KernelInfo_GetNodeName)( const OrtKernelInfo* info, char* out, size_t* size) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_NODE_NAME: usize = 244;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetNodeNameFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    out_: *mut core::ffi::c_char,
    size: *mut usize,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_node_name(&self) -> KernelInfo_GetNodeNameFn {
        self.f(IDX_KERNEL_INFO__GET_NODE_NAME)
    }
}

// OrtStatusPtr(* KernelInfo_GetLogger)( const OrtKernelInfo* info, const OrtLogger** logger) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_LOGGER: usize = 245;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetLoggerFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    logger: *const *const LoggerHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_logger(&self) -> KernelInfo_GetLoggerFn {
        self.f(IDX_KERNEL_INFO__GET_LOGGER)
    }
}

// OrtStatusPtr(* KernelContext_GetLogger)( const OrtKernelContext* context, const OrtLogger** logger) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_CONTEXT__GET_LOGGER: usize = 246;
#[cfg(feature = "custom-ops")]
pub type KernelContext_GetLoggerFn = unsafe extern "C" fn(
    context: *const KernelContextHandle,
    logger: *const *const LoggerHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_context__get_logger(&self) -> KernelContext_GetLoggerFn {
        self.f(IDX_KERNEL_CONTEXT__GET_LOGGER)
    }
}

// OrtStatusPtr(* KernelInfoGetConstantInput_tensor)( const OrtKernelInfo* info, size_t index, int* is_constant, const OrtValue** out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO_GET_CONSTANT_INPUT_TENSOR: usize = 249;
#[cfg(feature = "custom-ops")]
pub type KernelInfoGetConstantInput_tensorFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    index: usize,
    is_constant: *mut core::ffi::c_int,
    out_: *const *const ValueHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info_get_constant_input_tensor(
        &self,
    ) -> KernelInfoGetConstantInput_tensorFn {
        self.f(IDX_KERNEL_INFO_GET_CONSTANT_INPUT_TENSOR)
    }
}

// OrtStatusPtr(* KernelContext_GetAllocator)( const OrtKernelContext* context, const OrtMemoryInfo* mem_info, OrtAllocator** out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_CONTEXT__GET_ALLOCATOR: usize = 253;
#[cfg(feature = "custom-ops")]
pub type KernelContext_GetAllocatorFn = unsafe extern "C" fn(
    context: *const KernelContextHandle,
    mem_info: *const MemoryInfoHandle,
    out_: *mut *mut AllocatorHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_context__get_allocator(&self) -> KernelContext_GetAllocatorFn {
        self.f(IDX_KERNEL_CONTEXT__GET_ALLOCATOR)
    }
}

// OrtStatusPtr(* KernelContext_GetResource)( const OrtKernelContext* context, int resource_version, int resource_id, void** resource) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_CONTEXT__GET_RESOURCE: usize = 265;
#[cfg(feature = "custom-ops")]
pub type KernelContext_GetResourceFn = unsafe extern "C" fn(
    context: *const KernelContextHandle,
    resource_version: core::ffi::c_int,
    resource_id: core::ffi::c_int,
    resource: *mut *mut core::ffi::c_void,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_context__get_resource(&self) -> KernelContext_GetResourceFn {
        self.f(IDX_KERNEL_CONTEXT__GET_RESOURCE)
    }
}

// OrtStatusPtr(* KernelContext_ParallelFor)( const OrtKernelContext* context, void (*fn)(void*, size_t), size_t total, size_t num_batch, void* usr_data) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_CONTEXT__PARALLEL_FOR: usize = 274;
#[cfg(feature = "custom-ops")]
pub type KernelContext_ParallelForFn = unsafe extern "C" fn(
    context: *const KernelContextHandle,
    fn_: Option<unsafe extern "C" fn(*mut core::ffi::c_void, usize)>,
    total: usize,
    num_batch: usize,
    usr_data: *mut core::ffi::c_void,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_context__parallel_for(&self) -> KernelContext_ParallelForFn {
        self.f(IDX_KERNEL_CONTEXT__PARALLEL_FOR)
    }
}

// OrtStatusPtr(* KernelContext_GetScratchBuffer)( const OrtKernelContext* context, const OrtMemoryInfo* mem_info, size_t count_or_bytes, void** out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_CONTEXT__GET_SCRATCH_BUFFER: usize = 277;
#[cfg(feature = "custom-ops")]
pub type KernelContext_GetScratchBufferFn = unsafe extern "C" fn(
    context: *const KernelContextHandle,
    mem_info: *const MemoryInfoHandle,
    count_or_bytes: usize,
    out_: *mut *mut core::ffi::c_void,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_context__get_scratch_buffer(&self) -> KernelContext_GetScratchBufferFn {
        self.f(IDX_KERNEL_CONTEXT__GET_SCRATCH_BUFFER)
    }
}

// OrtStatusPtr(* KernelInfoGetAllocator)( const OrtKernelInfo* info, OrtMemType mem_type, OrtAllocator** out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO_GET_ALLOCATOR: usize = 278;
#[cfg(feature = "custom-ops")]
pub type KernelInfoGetAllocatorFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    mem_type: MemType,
    out_: *mut *mut AllocatorHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info_get_allocator(&self) -> KernelInfoGetAllocatorFn {
        self.f(IDX_KERNEL_INFO_GET_ALLOCATOR)
    }
}

// OrtStatusPtr(* KernelInfo_GetConfigEntries)( const OrtKernelInfo* info, OrtKeyValuePairs** out) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_CONFIG_ENTRIES: usize = 391;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetConfigEntriesFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    out_: *mut *mut KeyValuePairsHandle,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_config_entries(&self) -> KernelInfo_GetConfigEntriesFn {
        self.f(IDX_KERNEL_INFO__GET_CONFIG_ENTRIES)
    }
}

// OrtStatusPtr(* KernelInfo_GetOperatorDomain)( const OrtKernelInfo* info, char* out, size_t* size) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_OPERATOR_DOMAIN: usize = 392;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetOperatorDomainFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    out_: *mut core::ffi::c_char,
    size: *mut usize,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_operator_domain(&self) -> KernelInfo_GetOperatorDomainFn {
        self.f(IDX_KERNEL_INFO__GET_OPERATOR_DOMAIN)
    }
}

// OrtStatusPtr(* KernelInfo_GetOperatorType)( const OrtKernelInfo* info, char* out, size_t* size) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_OPERATOR_TYPE: usize = 393;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetOperatorTypeFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    out_: *mut core::ffi::c_char,
    size: *mut usize,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_operator_type(&self) -> KernelInfo_GetOperatorTypeFn {
        self.f(IDX_KERNEL_INFO__GET_OPERATOR_TYPE)
    }
}

// OrtStatusPtr(* KernelInfo_GetOperatorSinceVersion)( const OrtKernelInfo* info, int* since_version) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO__GET_OPERATOR_SINCE_VERSION: usize = 394;
#[cfg(feature = "custom-ops")]
pub type KernelInfo_GetOperatorSinceVersionFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    since_version: *mut core::ffi::c_int,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info__get_operator_since_version(
        &self,
    ) -> KernelInfo_GetOperatorSinceVersionFn {
        self.f(IDX_KERNEL_INFO__GET_OPERATOR_SINCE_VERSION)
    }
}

// OrtStatusPtr(* KernelInfoGetAttributeArray_string)( const OrtKernelInfo* info, const char* name, OrtAllocator* allocator, char*** out, size_t* size) __attribute__((warn_unused_result))
#[cfg(feature = "custom-ops")]
pub const IDX_KERNEL_INFO_GET_ATTRIBUTE_ARRAY_STRING: usize = 417;
#[cfg(feature = "custom-ops")]
pub type KernelInfoGetAttributeArray_stringFn = unsafe extern "C" fn(
    info: *const KernelInfoHandle,
    name: *const core::ffi::c_char,
    allocator: *mut AllocatorHandle,
    out_: *mut *mut *mut core::ffi::c_char,
    size: *mut usize,
) -> StatusPtr;
#[cfg(feature = "custom-ops")]
impl Api {
    #[inline]
    #[cfg(feature = "custom-ops")]
    pub unsafe fn kernel_info_get_attribute_array_string(
        &self,
    ) -> KernelInfoGetAttributeArray_stringFn {
        self.f(IDX_KERNEL_INFO_GET_ATTRIBUTE_ARRAY_STRING)
    }
}

// ── Execution-provider options (GPU/accelerators) ────────────────────────────────────────────────────────────────
// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_CUDA)( OrtSessionOptions* options, const OrtCUDAProviderOptions* cuda_options) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_CUDA: usize = 152;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_cudaFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    cuda_options: *const CUDAProviderOptionsHandle,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider_cuda(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_cudaFn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_CUDA)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_ROCM)( OrtSessionOptions* options, const OrtROCMProviderOptions* rocm_options) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_ROCM: usize = 153;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_rocmFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    rocm_options: *const ROCMProviderOptionsHandle,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider_rocm(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_rocmFn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_ROCM)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_OpenVINO)( OrtSessionOptions* options, const OrtOpenVINOProviderOptions* provider_options) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__OPEN_VINO: usize = 154;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_OpenVinoFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    provider_options: *const OpenVINOProviderOptionsHandle,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider__open_vino(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_OpenVinoFn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__OPEN_VINO)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_TensorRT)( OrtSessionOptions* options, const OrtTensorRTProviderOptions* tensorrt_options) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__TENSOR_RT: usize = 159;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_TensorRtFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    tensorrt_options: *const TensorRTProviderOptionsHandle,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider__tensor_rt(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_TensorRtFn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__TENSOR_RT)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_TensorRT_V2)( OrtSessionOptions* options, const OrtTensorRTProviderOptionsV2* tensorrt_options) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__TENSOR_RT_V2: usize = 170;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_TensorRt_v2Fn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    tensorrt_options: *const TensorRTProviderOptionsV2Handle,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider__tensor_rt_v2(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_TensorRt_v2Fn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__TENSOR_RT_V2)
    }
}

// OrtStatusPtr(* CreateTensorRTProviderOptions)( OrtTensorRTProviderOptionsV2** out) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_CREATE_TENSOR_RT_PROVIDER_OPTIONS: usize = 171;
#[cfg(feature = "ep")]
pub type CreateTensorRtProviderOptionsFn =
    unsafe extern "C" fn(out_: *mut *mut TensorRTProviderOptionsV2Handle) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn create_tensor_rt_provider_options(&self) -> CreateTensorRtProviderOptionsFn {
        self.f(IDX_CREATE_TENSOR_RT_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* UpdateTensorRTProviderOptions)( OrtTensorRTProviderOptionsV2* tensorrt_options, const char* const* provider_options_keys, const char* const* provider_options_values, size_t num_keys) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_UPDATE_TENSOR_RT_PROVIDER_OPTIONS: usize = 172;
#[cfg(feature = "ep")]
pub type UpdateTensorRtProviderOptionsFn = unsafe extern "C" fn(
    tensorrt_options: *mut TensorRTProviderOptionsV2Handle,
    provider_options_keys: *const *const core::ffi::c_char,
    provider_options_values: *const *const core::ffi::c_char,
    num_keys: usize,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn update_tensor_rt_provider_options(&self) -> UpdateTensorRtProviderOptionsFn {
        self.f(IDX_UPDATE_TENSOR_RT_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* GetTensorRTProviderOptionsAsString)( const OrtTensorRTProviderOptionsV2* tensorrt_options, OrtAllocator* allocator, char** ptr) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_GET_TENSOR_RT_PROVIDER_OPTIONS_AS_STRING: usize = 173;
#[cfg(feature = "ep")]
pub type GetTensorRtProviderOptionsAsStringFn = unsafe extern "C" fn(
    tensorrt_options: *const TensorRTProviderOptionsV2Handle,
    allocator: *mut AllocatorHandle,
    ptr: *mut *mut core::ffi::c_char,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn get_tensor_rt_provider_options_as_string(
        &self,
    ) -> GetTensorRtProviderOptionsAsStringFn {
        self.f(IDX_GET_TENSOR_RT_PROVIDER_OPTIONS_AS_STRING)
    }
}

// void(* ReleaseTensorRTProviderOptions)( OrtTensorRTProviderOptionsV2* input)
#[cfg(feature = "ep")]
pub const IDX_RELEASE_TENSOR_RT_PROVIDER_OPTIONS: usize = 174;
#[cfg(feature = "ep")]
pub type ReleaseTensorRtProviderOptionsFn =
    unsafe extern "C" fn(input: *mut TensorRTProviderOptionsV2Handle) -> ();
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn release_tensor_rt_provider_options(&self) -> ReleaseTensorRtProviderOptionsFn {
        self.f(IDX_RELEASE_TENSOR_RT_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_CUDA_V2)( OrtSessionOptions* options, const OrtCUDAProviderOptionsV2* cuda_options) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_CUDA_V2: usize = 204;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_cuda_v2Fn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    cuda_options: *const CUDAProviderOptionsV2Handle,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider_cuda_v2(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_cuda_v2Fn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_CUDA_V2)
    }
}

// OrtStatusPtr(* CreateCUDAProviderOptions)( OrtCUDAProviderOptionsV2** out) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_CREATE_CUDA_PROVIDER_OPTIONS: usize = 205;
#[cfg(feature = "ep")]
pub type CreateCudaProviderOptionsFn =
    unsafe extern "C" fn(out_: *mut *mut CUDAProviderOptionsV2Handle) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn create_cuda_provider_options(&self) -> CreateCudaProviderOptionsFn {
        self.f(IDX_CREATE_CUDA_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* UpdateCUDAProviderOptions)( OrtCUDAProviderOptionsV2* cuda_options, const char* const* provider_options_keys, const char* const* provider_options_values, size_t num_keys) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_UPDATE_CUDA_PROVIDER_OPTIONS: usize = 206;
#[cfg(feature = "ep")]
pub type UpdateCudaProviderOptionsFn = unsafe extern "C" fn(
    cuda_options: *mut CUDAProviderOptionsV2Handle,
    provider_options_keys: *const *const core::ffi::c_char,
    provider_options_values: *const *const core::ffi::c_char,
    num_keys: usize,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn update_cuda_provider_options(&self) -> UpdateCudaProviderOptionsFn {
        self.f(IDX_UPDATE_CUDA_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* GetCUDAProviderOptionsAsString)( const OrtCUDAProviderOptionsV2* cuda_options, OrtAllocator* allocator, char** ptr) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_GET_CUDA_PROVIDER_OPTIONS_AS_STRING: usize = 207;
#[cfg(feature = "ep")]
pub type GetCudaProviderOptionsAsStringFn = unsafe extern "C" fn(
    cuda_options: *const CUDAProviderOptionsV2Handle,
    allocator: *mut AllocatorHandle,
    ptr: *mut *mut core::ffi::c_char,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn get_cuda_provider_options_as_string(&self) -> GetCudaProviderOptionsAsStringFn {
        self.f(IDX_GET_CUDA_PROVIDER_OPTIONS_AS_STRING)
    }
}

// void(* ReleaseCUDAProviderOptions)( OrtCUDAProviderOptionsV2* input)
#[cfg(feature = "ep")]
pub const IDX_RELEASE_CUDA_PROVIDER_OPTIONS: usize = 208;
#[cfg(feature = "ep")]
pub type ReleaseCudaProviderOptionsFn =
    unsafe extern "C" fn(input: *mut CUDAProviderOptionsV2Handle) -> ();
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn release_cuda_provider_options(&self) -> ReleaseCudaProviderOptionsFn {
        self.f(IDX_RELEASE_CUDA_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_MIGraphX)( OrtSessionOptions* options, const OrtMIGraphXProviderOptions* migraphx_options) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_MI_GRAPH_X: usize = 209;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_miGraphXFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    migraphx_options: *const MIGraphXProviderOptionsHandle,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider_mi_graph_x(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_miGraphXFn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_MI_GRAPH_X)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_CANN)( OrtSessionOptions* options, const OrtCANNProviderOptions* cann_options) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_CANN: usize = 220;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_cannFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    cann_options: *const CANNProviderOptionsHandle,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider_cann(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_cannFn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER_CANN)
    }
}

// OrtStatusPtr(* CreateCANNProviderOptions)( OrtCANNProviderOptions** out) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_CREATE_CANN_PROVIDER_OPTIONS: usize = 221;
#[cfg(feature = "ep")]
pub type CreateCannProviderOptionsFn =
    unsafe extern "C" fn(out_: *mut *mut CANNProviderOptionsHandle) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn create_cann_provider_options(&self) -> CreateCannProviderOptionsFn {
        self.f(IDX_CREATE_CANN_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* UpdateCANNProviderOptions)( OrtCANNProviderOptions* cann_options, const char* const* provider_options_keys, const char* const* provider_options_values, size_t num_keys) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_UPDATE_CANN_PROVIDER_OPTIONS: usize = 222;
#[cfg(feature = "ep")]
pub type UpdateCannProviderOptionsFn = unsafe extern "C" fn(
    cann_options: *mut CANNProviderOptionsHandle,
    provider_options_keys: *const *const core::ffi::c_char,
    provider_options_values: *const *const core::ffi::c_char,
    num_keys: usize,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn update_cann_provider_options(&self) -> UpdateCannProviderOptionsFn {
        self.f(IDX_UPDATE_CANN_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* GetCANNProviderOptionsAsString)( const OrtCANNProviderOptions* cann_options, OrtAllocator* allocator, char** ptr) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_GET_CANN_PROVIDER_OPTIONS_AS_STRING: usize = 223;
#[cfg(feature = "ep")]
pub type GetCannProviderOptionsAsStringFn = unsafe extern "C" fn(
    cann_options: *const CANNProviderOptionsHandle,
    allocator: *mut AllocatorHandle,
    ptr: *mut *mut core::ffi::c_char,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn get_cann_provider_options_as_string(&self) -> GetCannProviderOptionsAsStringFn {
        self.f(IDX_GET_CANN_PROVIDER_OPTIONS_AS_STRING)
    }
}

// void(* ReleaseCANNProviderOptions)( OrtCANNProviderOptions* input)
#[cfg(feature = "ep")]
pub const IDX_RELEASE_CANN_PROVIDER_OPTIONS: usize = 224;
#[cfg(feature = "ep")]
pub type ReleaseCannProviderOptionsFn =
    unsafe extern "C" fn(input: *mut CANNProviderOptionsHandle) -> ();
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn release_cann_provider_options(&self) -> ReleaseCannProviderOptionsFn {
        self.f(IDX_RELEASE_CANN_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_Dnnl)( OrtSessionOptions* options, const OrtDnnlProviderOptions* dnnl_options) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__DNNL: usize = 239;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_DnnlFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    dnnl_options: *const DnnlProviderOptionsHandle,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider__dnnl(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_DnnlFn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__DNNL)
    }
}

// OrtStatusPtr(* CreateDnnlProviderOptions)( OrtDnnlProviderOptions** out) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_CREATE_DNNL_PROVIDER_OPTIONS: usize = 240;
#[cfg(feature = "ep")]
pub type CreateDnnlProviderOptionsFn =
    unsafe extern "C" fn(out_: *mut *mut DnnlProviderOptionsHandle) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn create_dnnl_provider_options(&self) -> CreateDnnlProviderOptionsFn {
        self.f(IDX_CREATE_DNNL_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* UpdateDnnlProviderOptions)( OrtDnnlProviderOptions* dnnl_options, const char* const* provider_options_keys, const char* const* provider_options_values, size_t num_keys) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_UPDATE_DNNL_PROVIDER_OPTIONS: usize = 241;
#[cfg(feature = "ep")]
pub type UpdateDnnlProviderOptionsFn = unsafe extern "C" fn(
    dnnl_options: *mut DnnlProviderOptionsHandle,
    provider_options_keys: *const *const core::ffi::c_char,
    provider_options_values: *const *const core::ffi::c_char,
    num_keys: usize,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn update_dnnl_provider_options(&self) -> UpdateDnnlProviderOptionsFn {
        self.f(IDX_UPDATE_DNNL_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* GetDnnlProviderOptionsAsString)( const OrtDnnlProviderOptions* dnnl_options, OrtAllocator* allocator, char** ptr) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_GET_DNNL_PROVIDER_OPTIONS_AS_STRING: usize = 242;
#[cfg(feature = "ep")]
pub type GetDnnlProviderOptionsAsStringFn = unsafe extern "C" fn(
    dnnl_options: *const DnnlProviderOptionsHandle,
    allocator: *mut AllocatorHandle,
    ptr: *mut *mut core::ffi::c_char,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn get_dnnl_provider_options_as_string(&self) -> GetDnnlProviderOptionsAsStringFn {
        self.f(IDX_GET_DNNL_PROVIDER_OPTIONS_AS_STRING)
    }
}

// void(* ReleaseDnnlProviderOptions)( OrtDnnlProviderOptions* input)
#[cfg(feature = "ep")]
pub const IDX_RELEASE_DNNL_PROVIDER_OPTIONS: usize = 243;
#[cfg(feature = "ep")]
pub type ReleaseDnnlProviderOptionsFn =
    unsafe extern "C" fn(input: *mut DnnlProviderOptionsHandle) -> ();
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn release_dnnl_provider_options(&self) -> ReleaseDnnlProviderOptionsFn {
        self.f(IDX_RELEASE_DNNL_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* CreateROCMProviderOptions)( OrtROCMProviderOptions** out) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_CREATE_ROCM_PROVIDER_OPTIONS: usize = 255;
#[cfg(feature = "ep")]
pub type CreateRocmProviderOptionsFn =
    unsafe extern "C" fn(out_: *mut *mut ROCMProviderOptionsHandle) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn create_rocm_provider_options(&self) -> CreateRocmProviderOptionsFn {
        self.f(IDX_CREATE_ROCM_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* UpdateROCMProviderOptions)( OrtROCMProviderOptions* rocm_options, const char* const* provider_options_keys, const char* const* provider_options_values, size_t num_keys) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_UPDATE_ROCM_PROVIDER_OPTIONS: usize = 256;
#[cfg(feature = "ep")]
pub type UpdateRocmProviderOptionsFn = unsafe extern "C" fn(
    rocm_options: *mut ROCMProviderOptionsHandle,
    provider_options_keys: *const *const core::ffi::c_char,
    provider_options_values: *const *const core::ffi::c_char,
    num_keys: usize,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn update_rocm_provider_options(&self) -> UpdateRocmProviderOptionsFn {
        self.f(IDX_UPDATE_ROCM_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* GetROCMProviderOptionsAsString)( const OrtROCMProviderOptions* rocm_options, OrtAllocator* allocator, char** ptr) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_GET_ROCM_PROVIDER_OPTIONS_AS_STRING: usize = 257;
#[cfg(feature = "ep")]
pub type GetRocmProviderOptionsAsStringFn = unsafe extern "C" fn(
    rocm_options: *const ROCMProviderOptionsHandle,
    allocator: *mut AllocatorHandle,
    ptr: *mut *mut core::ffi::c_char,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn get_rocm_provider_options_as_string(&self) -> GetRocmProviderOptionsAsStringFn {
        self.f(IDX_GET_ROCM_PROVIDER_OPTIONS_AS_STRING)
    }
}

// void(* ReleaseROCMProviderOptions)( OrtROCMProviderOptions* input)
#[cfg(feature = "ep")]
pub const IDX_RELEASE_ROCM_PROVIDER_OPTIONS: usize = 258;
#[cfg(feature = "ep")]
pub type ReleaseRocmProviderOptionsFn =
    unsafe extern "C" fn(input: *mut ROCMProviderOptionsHandle) -> ();
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn release_rocm_provider_options(&self) -> ReleaseRocmProviderOptionsFn {
        self.f(IDX_RELEASE_ROCM_PROVIDER_OPTIONS)
    }
}

// OrtStatusPtr(* UpdateTensorRTProviderOptionsWithValue)( OrtTensorRTProviderOptionsV2* tensorrt_options, const char* key, void* value) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_UPDATE_TENSOR_RT_PROVIDER_OPTIONS_WITH_VALUE: usize = 261;
#[cfg(feature = "ep")]
pub type UpdateTensorRtProviderOptionsWithValueFn = unsafe extern "C" fn(
    tensorrt_options: *mut TensorRTProviderOptionsV2Handle,
    key: *const core::ffi::c_char,
    value: *mut core::ffi::c_void,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn update_tensor_rt_provider_options_with_value(
        &self,
    ) -> UpdateTensorRtProviderOptionsWithValueFn {
        self.f(IDX_UPDATE_TENSOR_RT_PROVIDER_OPTIONS_WITH_VALUE)
    }
}

// OrtStatusPtr(* GetTensorRTProviderOptionsByName)( const OrtTensorRTProviderOptionsV2* tensorrt_options, const char* key, void** ptr) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_GET_TENSOR_RT_PROVIDER_OPTIONS_BY_NAME: usize = 262;
#[cfg(feature = "ep")]
pub type GetTensorRtProviderOptionsByNameFn = unsafe extern "C" fn(
    tensorrt_options: *const TensorRTProviderOptionsV2Handle,
    key: *const core::ffi::c_char,
    ptr: *mut *mut core::ffi::c_void,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn get_tensor_rt_provider_options_by_name(
        &self,
    ) -> GetTensorRtProviderOptionsByNameFn {
        self.f(IDX_GET_TENSOR_RT_PROVIDER_OPTIONS_BY_NAME)
    }
}

// OrtStatusPtr(* UpdateCUDAProviderOptionsWithValue)( OrtCUDAProviderOptionsV2* cuda_options, const char* key, void* value) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_UPDATE_CUDA_PROVIDER_OPTIONS_WITH_VALUE: usize = 263;
#[cfg(feature = "ep")]
pub type UpdateCudaProviderOptionsWithValueFn = unsafe extern "C" fn(
    cuda_options: *mut CUDAProviderOptionsV2Handle,
    key: *const core::ffi::c_char,
    value: *mut core::ffi::c_void,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn update_cuda_provider_options_with_value(
        &self,
    ) -> UpdateCudaProviderOptionsWithValueFn {
        self.f(IDX_UPDATE_CUDA_PROVIDER_OPTIONS_WITH_VALUE)
    }
}

// OrtStatusPtr(* GetCUDAProviderOptionsByName)( const OrtCUDAProviderOptionsV2* cuda_options, const char* key, void** ptr) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_GET_CUDA_PROVIDER_OPTIONS_BY_NAME: usize = 264;
#[cfg(feature = "ep")]
pub type GetCudaProviderOptionsByNameFn = unsafe extern "C" fn(
    cuda_options: *const CUDAProviderOptionsV2Handle,
    key: *const core::ffi::c_char,
    ptr: *mut *mut core::ffi::c_void,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn get_cuda_provider_options_by_name(&self) -> GetCudaProviderOptionsByNameFn {
        self.f(IDX_GET_CUDA_PROVIDER_OPTIONS_BY_NAME)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_OpenVINO_V2)( OrtSessionOptions* options, const char* const* provider_options_keys, const char* const* provider_options_values, size_t num_keys) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__OPEN_VINO_V2: usize = 275;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_OpenVino_v2Fn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    provider_options_keys: *const *const core::ffi::c_char,
    provider_options_values: *const *const core::ffi::c_char,
    num_keys: usize,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider__open_vino_v2(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_OpenVino_v2Fn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__OPEN_VINO_V2)
    }
}

// OrtStatusPtr(* SessionOptionsAppendExecutionProvider_VitisAI)( OrtSessionOptions* options, const char* const* provider_options_keys, const char* const* provider_options_values, size_t num_keys) __attribute__((warn_unused_result))
#[cfg(feature = "ep")]
pub const IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__VITIS_AI: usize = 276;
#[cfg(feature = "ep")]
pub type SessionOptionsAppendExecutionProvider_VitisAiFn = unsafe extern "C" fn(
    options: *mut SessionOptionsHandle,
    provider_options_keys: *const *const core::ffi::c_char,
    provider_options_values: *const *const core::ffi::c_char,
    num_keys: usize,
) -> StatusPtr;
#[cfg(feature = "ep")]
impl Api {
    #[inline]
    #[cfg(feature = "ep")]
    pub unsafe fn session_options_append_execution_provider__vitis_ai(
        &self,
    ) -> SessionOptionsAppendExecutionProvider_VitisAiFn {
        self.f(IDX_SESSION_OPTIONS_APPEND_EXECUTION_PROVIDER__VITIS_AI)
    }
}

// ── Sub-API getters / graph editing ────────────────────────────────────────────────────────────────
// const OrtModelEditorApi*(* GetModelEditorApi)(void)
#[cfg(feature = "model-editor")]
pub const IDX_GET_MODEL_EDITOR_API: usize = 291;
#[cfg(feature = "model-editor")]
pub type GetModelEditorApiFn = unsafe extern "C" fn() -> *const ModelEditorApi;
#[cfg(feature = "model-editor")]
impl Api {
    #[inline]
    #[cfg(feature = "model-editor")]
    pub unsafe fn get_model_editor_api(&self) -> GetModelEditorApiFn {
        self.f(IDX_GET_MODEL_EDITOR_API)
    }
}

// const OrtCompileApi*(* GetCompileApi)(void)
#[cfg(feature = "model-editor")]
pub const IDX_GET_COMPILE_API: usize = 294;
#[cfg(feature = "model-editor")]
pub type GetCompileApiFn = unsafe extern "C" fn() -> *const CompileApi;
#[cfg(feature = "model-editor")]
impl Api {
    #[inline]
    #[cfg(feature = "model-editor")]
    pub unsafe fn get_compile_api(&self) -> GetCompileApiFn {
        self.f(IDX_GET_COMPILE_API)
    }
}

// const OrtEpApi*(* GetEpApi)(void)
#[cfg(feature = "model-editor")]
pub const IDX_GET_EP_API: usize = 317;
#[cfg(feature = "model-editor")]
pub type GetEpApiFn = unsafe extern "C" fn() -> *const EpApi;
#[cfg(feature = "model-editor")]
impl Api {
    #[inline]
    #[cfg(feature = "model-editor")]
    pub unsafe fn get_ep_api(&self) -> GetEpApiFn {
        self.f(IDX_GET_EP_API)
    }
}

// const OrtInteropApi*(* GetInteropApi)(void)
#[cfg(feature = "model-editor")]
pub const IDX_GET_INTEROP_API: usize = 395;
#[cfg(feature = "model-editor")]
pub type GetInteropApiFn = unsafe extern "C" fn() -> *const InteropApi;
#[cfg(feature = "model-editor")]
impl Api {
    #[inline]
    #[cfg(feature = "model-editor")]
    pub unsafe fn get_interop_api(&self) -> GetInteropApiFn {
        self.f(IDX_GET_INTEROP_API)
    }
}

// ── Training API ────────────────────────────────────────────────────────────────
// const OrtTrainingApi*(* GetTrainingApi)(uint32_t version)
#[cfg(feature = "training")]
pub const IDX_GET_TRAINING_API: usize = 219;
#[cfg(feature = "training")]
pub type GetTrainingApiFn = unsafe extern "C" fn(version: u32) -> *const TrainingApiHandle;
#[cfg(feature = "training")]
impl Api {
    #[inline]
    #[cfg(feature = "training")]
    pub unsafe fn get_training_api(&self) -> GetTrainingApiFn {
        self.f(IDX_GET_TRAINING_API)
    }
}

// ── Sub-API structs (deref-style function tables; model-editor feature) ────
#[cfg(feature = "model-editor")]
#[repr(C)]
pub struct ModelEditorApi {
    pub CreateTensorTypeInfo: Option<
        unsafe extern "C" fn(
            tensor_info: *const TensorTypeAndShapeInfoHandle,
            type_info: *mut *mut TypeInfoHandle,
        ) -> StatusPtr,
    >,
    pub CreateSparseTensorTypeInfo: Option<
        unsafe extern "C" fn(
            tensor_info: *const TensorTypeAndShapeInfoHandle,
            type_info: *mut *mut TypeInfoHandle,
        ) -> StatusPtr,
    >,
    pub CreateMapTypeInfo: Option<
        unsafe extern "C" fn(
            map_key_type: ElementType,
            map_value_type: *const TypeInfoHandle,
            type_info: *mut *mut TypeInfoHandle,
        ) -> StatusPtr,
    >,
    pub CreateSequenceTypeInfo: Option<
        unsafe extern "C" fn(
            sequence_type: *const TypeInfoHandle,
            type_info: *mut *mut TypeInfoHandle,
        ) -> StatusPtr,
    >,
    pub CreateOptionalTypeInfo: Option<
        unsafe extern "C" fn(
            contained_type: *const TypeInfoHandle,
            type_info: *mut *mut TypeInfoHandle,
        ) -> StatusPtr,
    >,
    pub CreateValueInfo: Option<
        unsafe extern "C" fn(
            name: *const core::ffi::c_char,
            type_info: *const TypeInfoHandle,
            value_info: *mut *mut ValueInfoHandle,
        ) -> StatusPtr,
    >,
    pub CreateNode: Option<
        unsafe extern "C" fn(
            operator_name: *const core::ffi::c_char,
            domain_name: *const core::ffi::c_char,
            node_name: *const core::ffi::c_char,
            input_names: *const *const core::ffi::c_char,
            input_names_len: usize,
            output_names: *const *const core::ffi::c_char,
            output_names_len: usize,
            attributes: *mut *mut OpAttrHandle,
            attribs_len: usize,
            node: *mut *mut NodeHandle,
        ) -> StatusPtr,
    >,
    pub CreateGraph: Option<unsafe extern "C" fn(graph: *mut *mut GraphHandle) -> StatusPtr>,
    pub SetGraphInputs: Option<
        unsafe extern "C" fn(
            graph: *mut GraphHandle,
            inputs: *mut *mut ValueInfoHandle,
            inputs_len: usize,
        ) -> StatusPtr,
    >,
    pub SetGraphOutputs: Option<
        unsafe extern "C" fn(
            graph: *mut GraphHandle,
            outputs: *mut *mut ValueInfoHandle,
            outputs_len: usize,
        ) -> StatusPtr,
    >,
    pub AddInitializerToGraph: Option<
        unsafe extern "C" fn(
            graph: *mut GraphHandle,
            name: *const core::ffi::c_char,
            tensor: *mut ValueHandle,
            data_is_external: bool,
        ) -> StatusPtr,
    >,
    pub AddNodeToGraph:
        Option<unsafe extern "C" fn(graph: *mut GraphHandle, node: *mut NodeHandle) -> StatusPtr>,
    pub CreateModel: Option<
        unsafe extern "C" fn(
            domain_names: *const *const core::ffi::c_char,
            opset_versions: *const core::ffi::c_int,
            opset_entries_len: usize,
            model: *mut *mut ModelHandle,
        ) -> StatusPtr,
    >,
    pub AddGraphToModel:
        Option<unsafe extern "C" fn(model: *mut ModelHandle, graph: *mut GraphHandle) -> StatusPtr>,
    pub CreateSessionFromModel: Option<
        unsafe extern "C" fn(
            env: *const EnvHandle,
            model: *const ModelHandle,
            options: *const SessionOptionsHandle,
            out_: *mut *mut SessionHandle,
        ) -> StatusPtr,
    >,
    pub CreateModelEditorSession: Option<
        unsafe extern "C" fn(
            env: *const EnvHandle,
            model_path: *const core::ffi::c_char,
            options: *const SessionOptionsHandle,
            out_: *mut *mut SessionHandle,
        ) -> StatusPtr,
    >,
    pub CreateModelEditorSessionFromArray: Option<
        unsafe extern "C" fn(
            env: *const EnvHandle,
            model_data: *const core::ffi::c_void,
            model_data_length: usize,
            options: *const SessionOptionsHandle,
            out_: *mut *mut SessionHandle,
        ) -> StatusPtr,
    >,
    pub SessionGetOpsetForDomain: Option<
        unsafe extern "C" fn(
            session: *const SessionHandle,
            domain: *const core::ffi::c_char,
            opset: *mut core::ffi::c_int,
        ) -> StatusPtr,
    >,
    pub ApplyModelToModelEditorSession: Option<
        unsafe extern "C" fn(session: *mut SessionHandle, model: *mut ModelHandle) -> StatusPtr,
    >,
    pub FinalizeModelEditorSession: Option<
        unsafe extern "C" fn(
            session: *mut SessionHandle,
            options: *const SessionOptionsHandle,
            prepacked_weights_container: *mut PrepackedWeightsContainerHandle,
        ) -> StatusPtr,
    >,
}
#[cfg(feature = "model-editor")]
#[repr(C)]
pub struct CompileApi {
    pub ReleaseModelCompilationOptions:
        Option<unsafe extern "C" fn(input: *mut ModelCompilationOptionsHandle) -> ()>,
    pub CreateModelCompilationOptionsFromSessionOptions: Option<
        unsafe extern "C" fn(
            env: *const EnvHandle,
            session_options: *const SessionOptionsHandle,
            out_: *mut *mut ModelCompilationOptionsHandle,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetInputModelPath: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            input_model_path: *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetInputModelFromBuffer: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            input_model_data: *const core::ffi::c_void,
            input_model_data_size: usize,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetOutputModelPath: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            output_model_path: *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetOutputModelExternalInitializersFile: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            external_initializers_file_path: *const core::ffi::c_char,
            external_initializers_size_threshold: usize,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetOutputModelBuffer: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            allocator: *mut AllocatorHandle,
            output_model_buffer_ptr: *mut *mut core::ffi::c_void,
            output_model_buffer_size_ptr: *mut usize,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetEpContextEmbedMode: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            embed_ep_context_in_model: bool,
        ) -> StatusPtr,
    >,
    pub CompileModel: Option<
        unsafe extern "C" fn(
            env: *const EnvHandle,
            model_options: *const ModelCompilationOptionsHandle,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetFlags: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            flags: u32,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetEpContextBinaryInformation: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            output_directory: *const core::ffi::c_char,
            model_name: *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetGraphOptimizationLevel: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            graph_optimization_level: GraphOptimizationLevel,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetOutputModelWriteFunc: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            write_func: WriteBufferFuncHandle,
            state: *mut core::ffi::c_void,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetOutputModelGetInitializerLocationFunc: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            get_initializer_location_func: GetInitializerLocationFuncHandle,
            state: *mut core::ffi::c_void,
        ) -> StatusPtr,
    >,
    pub ModelCompilationOptions_SetInputModel: Option<
        unsafe extern "C" fn(
            model_compile_options: *mut ModelCompilationOptionsHandle,
            model: *const ModelHandle,
        ) -> StatusPtr,
    >,
}
#[cfg(feature = "model-editor")]
#[repr(C)]
pub struct InteropApi {
    pub CreateExternalResourceImporterForDevice: Option<
        unsafe extern "C" fn(
            ep_device: *const EpDeviceHandle,
            out_importer: *mut *mut ExternalResourceImporterHandle,
        ) -> StatusPtr,
    >,
    pub ReleaseExternalResourceImporter:
        Option<unsafe extern "C" fn(input: *mut ExternalResourceImporterHandle) -> ()>,
    pub CanImportMemory: Option<
        unsafe extern "C" fn(
            importer: *const ExternalResourceImporterHandle,
            handle_type: ExternalMemoryHandleTypeHandle,
            out_supported: *mut bool,
        ) -> StatusPtr,
    >,
    pub ImportMemory: Option<
        unsafe extern "C" fn(
            importer: *mut ExternalResourceImporterHandle,
            desc: *const ExternalMemoryDescriptorHandle,
            out_handle: *mut *mut ExternalMemoryHandleHandle,
        ) -> StatusPtr,
    >,
    pub ReleaseExternalMemoryHandle:
        Option<unsafe extern "C" fn(input: *mut ExternalMemoryHandleHandle) -> ()>,
    pub CreateTensorFromMemory: Option<
        unsafe extern "C" fn(
            importer: *mut ExternalResourceImporterHandle,
            mem_handle: *const ExternalMemoryHandleHandle,
            tensor_desc: *const ExternalTensorDescriptorHandle,
            out_tensor: *mut *mut ValueHandle,
        ) -> StatusPtr,
    >,
    pub CanImportSemaphore: Option<
        unsafe extern "C" fn(
            importer: *const ExternalResourceImporterHandle,
            type_: ExternalSemaphoreTypeHandle,
            out_supported: *mut bool,
        ) -> StatusPtr,
    >,
    pub ImportSemaphore: Option<
        unsafe extern "C" fn(
            importer: *mut ExternalResourceImporterHandle,
            desc: *const ExternalSemaphoreDescriptorHandle,
            out_handle: *mut *mut ExternalSemaphoreHandleHandle,
        ) -> StatusPtr,
    >,
    pub ReleaseExternalSemaphoreHandle:
        Option<unsafe extern "C" fn(input: *mut ExternalSemaphoreHandleHandle) -> ()>,
    pub WaitSemaphore: Option<
        unsafe extern "C" fn(
            importer: *mut ExternalResourceImporterHandle,
            semaphore_handle: *mut ExternalSemaphoreHandleHandle,
            stream: *mut SyncStreamHandle,
            value: u64,
        ) -> StatusPtr,
    >,
    pub SignalSemaphore: Option<
        unsafe extern "C" fn(
            importer: *mut ExternalResourceImporterHandle,
            semaphore_handle: *mut ExternalSemaphoreHandleHandle,
            stream: *mut SyncStreamHandle,
            value: u64,
        ) -> StatusPtr,
    >,
    pub InitGraphicsInteropForEpDevice: Option<
        unsafe extern "C" fn(
            ep_device: *const EpDeviceHandle,
            config: *const GraphicsInteropConfigHandle,
        ) -> StatusPtr,
    >,
    pub DeinitGraphicsInteropForEpDevice:
        Option<unsafe extern "C" fn(ep_device: *const EpDeviceHandle) -> StatusPtr>,
}
#[cfg(feature = "model-editor")]
#[repr(C)]
pub struct EpApi {
    pub CreateEpDevice: Option<
        unsafe extern "C" fn(
            ep_factory: *mut EpFactoryHandle,
            hardware_device: *const HardwareDeviceHandle,
            ep_metadata: *const KeyValuePairsHandle,
            ep_options: *const KeyValuePairsHandle,
            ep_device: *mut *mut EpDeviceHandle,
        ) -> StatusPtr,
    >,
    pub ReleaseEpDevice: Option<unsafe extern "C" fn(input: *mut EpDeviceHandle) -> ()>,
    pub EpGraphSupportInfo_AddNodesToFuse: Option<
        unsafe extern "C" fn(
            graph_support_info: *mut EpGraphSupportInfoHandle,
            nodes: *const *const NodeHandle,
            num_nodes: usize,
            node_fusion_options: *const NodeFusionOptionsHandle,
        ) -> StatusPtr,
    >,
    pub EpGraphSupportInfo_AddSingleNode: Option<
        unsafe extern "C" fn(
            graph_support_info: *mut EpGraphSupportInfoHandle,
            node: *const NodeHandle,
        ) -> StatusPtr,
    >,
    pub NodeComputeContext_NodeName: Option<
        unsafe extern "C" fn(context: *const NodeComputeContextHandle) -> *const core::ffi::c_char,
    >,
    pub EpDevice_AddAllocatorInfo: Option<
        unsafe extern "C" fn(
            ep_device: *mut EpDeviceHandle,
            allocator_memory_info: *const MemoryInfoHandle,
        ) -> StatusPtr,
    >,
    pub MemoryInfo_GetMemoryDevice: Option<
        unsafe extern "C" fn(memory_info: *const MemoryInfoHandle) -> *const MemoryDeviceHandle,
    >,
    pub Value_GetMemoryDevice:
        Option<unsafe extern "C" fn(value: *const ValueHandle) -> *const MemoryDeviceHandle>,
    pub MemoryDevice_AreEqual: Option<
        unsafe extern "C" fn(a: *const MemoryDeviceHandle, b: *const MemoryDeviceHandle) -> bool,
    >,
    pub MemoryDevice_GetDeviceType: Option<
        unsafe extern "C" fn(
            memory_device: *const MemoryDeviceHandle,
        ) -> MemoryInfoDeviceTypeHandle,
    >,
    pub MemoryDevice_GetMemoryType:
        Option<unsafe extern "C" fn(memory_device: *const MemoryDeviceHandle) -> i32>,
    pub MemoryDevice_GetVendorId:
        Option<unsafe extern "C" fn(memory_device: *const MemoryDeviceHandle) -> u32>,
    pub MemoryDevice_GetDeviceId:
        Option<unsafe extern "C" fn(memory_device: *const MemoryDeviceHandle) -> u32>,
    pub SyncStream_GetImpl: Option<
        unsafe extern "C" fn(stream: *const SyncStreamHandle) -> *const SyncStreamImplHandle,
    >,
    pub SyncStream_GetSyncId: Option<unsafe extern "C" fn(stream: *const SyncStreamHandle) -> u64>,
    pub GetSyncIdForLastWaitOnSyncStream: Option<
        unsafe extern "C" fn(
            producer_stream: *const SyncStreamHandle,
            consumer_stream: *const SyncStreamHandle,
        ) -> u64,
    >,
    pub CreateHardwareDevice: Option<
        unsafe extern "C" fn(
            type_: i32,
            vendor_id: u32,
            device_id: u32,
            vendor_name: *const core::ffi::c_char,
            metadata: *const KeyValuePairsHandle,
            hardware_device: *mut *mut HardwareDeviceHandle,
        ) -> StatusPtr,
    >,
    pub ReleaseHardwareDevice: Option<unsafe extern "C" fn(input: *mut HardwareDeviceHandle) -> ()>,
    pub CreateKernelRegistry:
        Option<unsafe extern "C" fn(kernel_registry: *mut *mut KernelRegistryHandle) -> StatusPtr>,
    pub ReleaseKernelRegistry: Option<unsafe extern "C" fn(input: *mut KernelRegistryHandle) -> ()>,
    pub KernelRegistry_AddKernel: Option<
        unsafe extern "C" fn(
            kernel_registry: *mut KernelRegistryHandle,
            kernel_def: *const KernelDefHandle,
            kernel_create_func: KernelCreateFuncHandle,
            kernel_create_func_state: *mut core::ffi::c_void,
        ) -> StatusPtr,
    >,
    pub CreateKernelDefBuilder: Option<
        unsafe extern "C" fn(kernel_def_builder_out: *mut *mut KernelDefBuilderHandle) -> StatusPtr,
    >,
    pub ReleaseKernelDefBuilder:
        Option<unsafe extern "C" fn(input: *mut KernelDefBuilderHandle) -> ()>,
    pub KernelDefBuilder_SetOperatorType: Option<
        unsafe extern "C" fn(
            kernel_def_builder: *mut KernelDefBuilderHandle,
            op_type: *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub KernelDefBuilder_SetDomain: Option<
        unsafe extern "C" fn(
            kernel_def_builder: *mut KernelDefBuilderHandle,
            domain: *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub KernelDefBuilder_SetSinceVersion: Option<
        unsafe extern "C" fn(
            kernel_def_builder: *mut KernelDefBuilderHandle,
            since_version_start: core::ffi::c_int,
            since_version_end: core::ffi::c_int,
        ) -> StatusPtr,
    >,
    pub KernelDefBuilder_SetExecutionProvider: Option<
        unsafe extern "C" fn(
            kernel_def_builder: *mut KernelDefBuilderHandle,
            ep_name: *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub KernelDefBuilder_SetInputMemType: Option<
        unsafe extern "C" fn(
            kernel_def_builder: *mut KernelDefBuilderHandle,
            input_index: usize,
            mem_type: MemType,
        ) -> StatusPtr,
    >,
    pub KernelDefBuilder_SetOutputMemType: Option<
        unsafe extern "C" fn(
            kernel_def_builder: *mut KernelDefBuilderHandle,
            output_index: usize,
            mem_type: MemType,
        ) -> StatusPtr,
    >,
    pub KernelDefBuilder_AddTypeConstraint: Option<
        unsafe extern "C" fn(
            kernel_def_builder: *mut KernelDefBuilderHandle,
            arg_name: *const core::ffi::c_char,
            types: *const *const DataTypeHandle,
            num_types: usize,
        ) -> StatusPtr,
    >,
    pub KernelDefBuilder_AddInputOutputAliases: Option<
        unsafe extern "C" fn(
            kernel_def_builder: *mut KernelDefBuilderHandle,
            input_indices: *mut core::ffi::c_int,
            output_indices: *mut core::ffi::c_int,
            num_io_indices: usize,
        ) -> StatusPtr,
    >,
    pub KernelDefBuilder_AddInputOutputMutableAliases: Option<
        unsafe extern "C" fn(
            kernel_def_builder: *mut KernelDefBuilderHandle,
            input_indices: *mut core::ffi::c_int,
            output_indices: *mut core::ffi::c_int,
            num_io_indices: usize,
        ) -> StatusPtr,
    >,
    pub KernelDefBuilder_Build: Option<
        unsafe extern "C" fn(
            kernel_def_builder: *mut KernelDefBuilderHandle,
            kernel_def_out: *mut *mut KernelDefHandle,
        ) -> StatusPtr,
    >,
    pub ReleaseKernelDef: Option<unsafe extern "C" fn(input: *mut KernelDefHandle) -> ()>,
    pub KernelDef_GetOperatorType: Option<
        unsafe extern "C" fn(kernel_def: *const KernelDefHandle) -> *const core::ffi::c_char,
    >,
    pub KernelDef_GetDomain: Option<
        unsafe extern "C" fn(kernel_def: *const KernelDefHandle) -> *const core::ffi::c_char,
    >,
    pub KernelDef_GetSinceVersion: Option<
        unsafe extern "C" fn(
            kernel_def: *const KernelDefHandle,
            start_version: *mut core::ffi::c_int,
            end_version: *mut core::ffi::c_int,
        ) -> StatusPtr,
    >,
    pub KernelDef_GetExecutionProvider: Option<
        unsafe extern "C" fn(kernel_def: *const KernelDefHandle) -> *const core::ffi::c_char,
    >,
    pub KernelDef_GetInputMemType: Option<
        unsafe extern "C" fn(
            kernel_def: *const KernelDefHandle,
            input_index: usize,
            mem_type: *mut MemType,
        ) -> StatusPtr,
    >,
    pub KernelDef_GetOutputMemType: Option<
        unsafe extern "C" fn(
            kernel_def: *const KernelDefHandle,
            output_index: usize,
            mem_type: *mut MemType,
        ) -> StatusPtr,
    >,
    pub GetTensorDataType: Option<
        unsafe extern "C" fn(
            elem_type: ElementType,
            out_: *const *const DataTypeHandle,
        ) -> StatusPtr,
    >,
    pub EpGraphSupportInfo_LookUpKernel: Option<
        unsafe extern "C" fn(
            graph_support_info: *mut EpGraphSupportInfoHandle,
            node: *const NodeHandle,
            out_kernel_def: *const *const KernelDefHandle,
        ) -> StatusPtr,
    >,
    pub SharedPrePackedWeightCache_StoreWeightData: Option<
        unsafe extern "C" fn(
            prepacked_weight_cache: *mut SharedPrePackedWeightCacheHandle,
            buffer_data_ptrs: *mut *mut core::ffi::c_void,
            buffer_data_sizes: *mut usize,
            num_buffers: usize,
        ) -> StatusPtr,
    >,
    pub KernelInfo_GetEp: Option<
        unsafe extern "C" fn(
            info: *const KernelInfoHandle,
            ep: *const *const EpHandle,
        ) -> StatusPtr,
    >,
    pub DeviceEpIncompatibilityDetails_SetDetails: Option<
        unsafe extern "C" fn(
            details: *mut DeviceEpIncompatibilityDetailsHandle,
            reasons_bitmask: u32,
            error_code: i32,
            notes: *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub CreateIfKernel: Option<
        unsafe extern "C" fn(
            kernel_info: *const KernelInfoHandle,
            kernel_out: *mut *mut KernelImplHandle,
        ) -> StatusPtr,
    >,
    pub CreateLoopKernel: Option<
        unsafe extern "C" fn(
            kernel_info: *const KernelInfoHandle,
            helper: *mut LoopKernelHelperHandle,
            kernel_out: *mut *mut KernelImplHandle,
        ) -> StatusPtr,
    >,
    pub CreateScanKernel: Option<
        unsafe extern "C" fn(
            kernel_info: *const KernelInfoHandle,
            helper: *mut ScanKernelHelperHandle,
            kernel_out: *mut *mut KernelImplHandle,
        ) -> StatusPtr,
    >,
    pub ReleaseKernelImpl: Option<unsafe extern "C" fn(input: *mut KernelImplHandle) -> ()>,
    pub GetEnvConfigEntries:
        Option<unsafe extern "C" fn(config_entries: *mut *mut KeyValuePairsHandle) -> StatusPtr>,
    pub GetOpSchema: Option<
        unsafe extern "C" fn(
            name: *const core::ffi::c_char,
            max_inclusive_version: core::ffi::c_int,
            domain: *const core::ffi::c_char,
            out_schema: *mut *mut OpSchemaHandle,
        ) -> StatusPtr,
    >,
    pub ReleaseOpSchema: Option<unsafe extern "C" fn(input: *mut OpSchemaHandle) -> ()>,
    pub OpSchema_GetSinceVersion: Option<
        unsafe extern "C" fn(
            schema: *const OpSchemaHandle,
            out_: *mut core::ffi::c_int,
        ) -> StatusPtr,
    >,
    pub OpSchema_GetNumInputs:
        Option<unsafe extern "C" fn(schema: *const OpSchemaHandle, out_: *mut usize) -> StatusPtr>,
    pub OpSchema_GetInputName: Option<
        unsafe extern "C" fn(
            schema: *const OpSchemaHandle,
            index: usize,
            out_: *const *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub OpSchema_GetInputTypeConstraint: Option<
        unsafe extern "C" fn(
            schema: *const OpSchemaHandle,
            index: usize,
            out_: *const *const OpSchemaTypeConstraintHandle,
        ) -> StatusPtr,
    >,
    pub OpSchema_GetNumOutputs:
        Option<unsafe extern "C" fn(schema: *const OpSchemaHandle, out_: *mut usize) -> StatusPtr>,
    pub OpSchema_GetOutputName: Option<
        unsafe extern "C" fn(
            schema: *const OpSchemaHandle,
            index: usize,
            out_: *const *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub OpSchema_GetOutputTypeConstraint: Option<
        unsafe extern "C" fn(
            schema: *const OpSchemaHandle,
            index: usize,
            out_: *const *const OpSchemaTypeConstraintHandle,
        ) -> StatusPtr,
    >,
    pub OpSchema_GetTypeConstraintCount:
        Option<unsafe extern "C" fn(schema: *const OpSchemaHandle, out_: *mut usize) -> StatusPtr>,
    pub OpSchema_GetTypeConstraint: Option<
        unsafe extern "C" fn(
            schema: *const OpSchemaHandle,
            index: usize,
            out_: *const *const OpSchemaTypeConstraintHandle,
        ) -> StatusPtr,
    >,
    pub OpSchemaTypeConstraint_GetTypeParamName: Option<
        unsafe extern "C" fn(
            type_constraint: *const OpSchemaTypeConstraintHandle,
            out_: *const *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub OpSchemaTypeConstraint_GetAllowedTypes: Option<
        unsafe extern "C" fn(
            type_constraint: *const OpSchemaTypeConstraintHandle,
            out_types: *const *const *const core::ffi::c_char,
            num_types: *mut usize,
        ) -> StatusPtr,
    >,
    pub OpSchemaTypeConstraint_GetInputIndices: Option<
        unsafe extern "C" fn(
            type_constraint: *const OpSchemaTypeConstraintHandle,
            out_indices: *const *const usize,
            count: *mut usize,
        ) -> StatusPtr,
    >,
    pub OpSchemaTypeConstraint_GetOutputIndices: Option<
        unsafe extern "C" fn(
            type_constraint: *const OpSchemaTypeConstraintHandle,
            out_indices: *const *const usize,
            count: *mut usize,
        ) -> StatusPtr,
    >,
    pub CreateProfilingEvent: Option<
        unsafe extern "C" fn(
            category: ProfilingEventCategoryHandle,
            process_id: i32,
            thread_id: i32,
            event_name: *const core::ffi::c_char,
            timestamp_us: i64,
            duration_us: i64,
            arg_keys: *const *const core::ffi::c_char,
            arg_values: *const *const core::ffi::c_char,
            num_args: usize,
            out_: *mut *mut ProfilingEventHandle,
        ) -> StatusPtr,
    >,
    pub ReleaseProfilingEvent: Option<unsafe extern "C" fn(input: *mut ProfilingEventHandle) -> ()>,
    pub ProfilingEvent_GetCategory: Option<
        unsafe extern "C" fn(
            event: *const ProfilingEventHandle,
            out_: *mut ProfilingEventCategoryHandle,
        ) -> StatusPtr,
    >,
    pub ProfilingEvent_GetName: Option<
        unsafe extern "C" fn(
            event: *const ProfilingEventHandle,
            out_: *const *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub ProfilingEvent_GetTimestampUs: Option<
        unsafe extern "C" fn(event: *const ProfilingEventHandle, out_: *mut i64) -> StatusPtr,
    >,
    pub ProfilingEvent_GetDurationUs: Option<
        unsafe extern "C" fn(event: *const ProfilingEventHandle, out_: *mut i64) -> StatusPtr,
    >,
    pub ProfilingEvent_GetArgValue: Option<
        unsafe extern "C" fn(
            event: *const ProfilingEventHandle,
            key: *const core::ffi::c_char,
            out_: *const *const core::ffi::c_char,
        ) -> StatusPtr,
    >,
    pub ProfilingEventsContainer_AddEvents: Option<
        unsafe extern "C" fn(
            events_container: *mut ProfilingEventsContainerHandle,
            events: *const *const ProfilingEventHandle,
            num_events: usize,
        ) -> StatusPtr,
    >,
}