/* automatically generated by rust-bindgen 0.69.5 */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
    storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage }
    }
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val {
            *byte |= mask;
        } else {
            *byte &= !mask;
        }
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
}
#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
    #[inline]
    pub const fn new() -> Self {
        __IncompleteArrayField(::std::marker::PhantomData, [])
    }
    #[inline]
    pub fn as_ptr(&self) -> *const T {
        self as *const _ as *const T
    }
    #[inline]
    pub fn as_mut_ptr(&mut self) -> *mut T {
        self as *mut _ as *mut T
    }
    #[inline]
    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
        ::std::slice::from_raw_parts(self.as_ptr(), len)
    }
    #[inline]
    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
    }
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        fmt.write_str("__IncompleteArrayField")
    }
}
pub const LITERT_HAS_SYNC_FENCE_SUPPORT: u32 = 0;
pub const LITERT_HAS_AHWB_SUPPORT_DEFAULT: u32 = 0;
pub const LITERT_HAS_OPENGL_SUPPORT_DEFAULT: u32 = 0;
pub const LITERT_HAS_ION_SUPPORT_DEFAULT: u32 = 0;
pub const LITERT_HAS_DMABUF_SUPPORT_DEFAULT: u32 = 0;
pub const LITERT_HAS_FASTRPC_SUPPORT_DEFAULT: u32 = 0;
pub const LITERT_HAS_METAL_SUPPORT_DEFAULT: u32 = 1;
pub const LITERT_HAS_OPENCL_SUPPORT_DEFAULT: u32 = 0;
pub const LITERT_HAS_VULKAN_SUPPORT_DEFAULT: u32 = 0;
pub const LITERT_HAS_WEBGPU_SUPPORT_DEFAULT: u32 = 1;
pub const LITERT_HAS_METAL_SUPPORT: u32 = 1;
pub const LITERT_HAS_OPENCL_SUPPORT: u32 = 0;
pub const LITERT_HAS_WEBGPU_SUPPORT: u32 = 1;
pub const LITERT_HAS_VULKAN_SUPPORT: u32 = 0;
pub const LITERT_HAS_OPENGL_SUPPORT: u32 = 0;
pub const LITERT_HAS_AHWB_SUPPORT: u32 = 0;
pub const LITERT_HAS_ION_SUPPORT: u32 = 0;
pub const LITERT_HAS_DMABUF_SUPPORT: u32 = 0;
pub const LITERT_HAS_FASTRPC_SUPPORT: u32 = 0;
pub const LITERT_API_VERSION_MAJOR: u32 = 0;
pub const LITERT_API_VERSION_MINOR: u32 = 1;
pub const LITERT_API_VERSION_PATCH: u32 = 0;
pub const LITERT_TENSOR_MAX_RANK: u32 = 8;
pub const LITERT_HOST_MEMORY_BUFFER_ALIGNMENT: u32 = 64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtAcceleratorT {
    _unused: [u8; 0],
}
pub type LiteRtAccelerator = *mut LiteRtAcceleratorT;
pub type LiteRtAcceleratorConst = *const LiteRtAcceleratorT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtDelegateWrapperT {
    _unused: [u8; 0],
}
pub type LiteRtDelegateWrapper = *mut LiteRtDelegateWrapperT;
pub type LiteRtDelegateWrapperConst = *const LiteRtDelegateWrapperT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtCompiledModelT {
    _unused: [u8; 0],
}
pub type LiteRtCompiledModel = *mut LiteRtCompiledModelT;
pub type LiteRtCompiledModelConst = *const LiteRtCompiledModelT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtEnvironmentT {
    _unused: [u8; 0],
}
pub type LiteRtEnvironment = *mut LiteRtEnvironmentT;
pub type LiteRtEnvironmentConst = *const LiteRtEnvironmentT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtEnvironmentOptionsT {
    _unused: [u8; 0],
}
pub type LiteRtEnvironmentOptions = *mut LiteRtEnvironmentOptionsT;
pub type LiteRtEnvironmentOptionsConst = *const LiteRtEnvironmentOptionsT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtEventT {
    _unused: [u8; 0],
}
pub type LiteRtEvent = *mut LiteRtEventT;
pub type LiteRtEventConst = *const LiteRtEventT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtLoggerT {
    _unused: [u8; 0],
}
pub type LiteRtLogger = *mut LiteRtLoggerT;
pub type LiteRtLoggerConst = *const LiteRtLoggerT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtMetricsT {
    _unused: [u8; 0],
}
pub type LiteRtMetrics = *mut LiteRtMetricsT;
pub type LiteRtMetricsConst = *const LiteRtMetricsT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtWeightsT {
    _unused: [u8; 0],
}
pub type LiteRtWeights = *mut LiteRtWeightsT;
pub type LiteRtWeightsConst = *const LiteRtWeightsT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtTensorT {
    _unused: [u8; 0],
}
pub type LiteRtTensor = *mut LiteRtTensorT;
pub type LiteRtTensorConst = *const LiteRtTensorT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtOpT {
    _unused: [u8; 0],
}
pub type LiteRtOp = *mut LiteRtOpT;
pub type LiteRtOpConst = *const LiteRtOpT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtSubgraphT {
    _unused: [u8; 0],
}
pub type LiteRtSubgraph = *mut LiteRtSubgraphT;
pub type LiteRtSubgraphConst = *const LiteRtSubgraphT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtSignatureT {
    _unused: [u8; 0],
}
pub type LiteRtSignature = *mut LiteRtSignatureT;
pub type LiteRtSignatureConst = *const LiteRtSignatureT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtModelT {
    _unused: [u8; 0],
}
pub type LiteRtModel = *mut LiteRtModelT;
pub type LiteRtModelConst = *const LiteRtModelT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtOpListT {
    _unused: [u8; 0],
}
pub type LiteRtOpList = *mut LiteRtOpListT;
pub type LiteRtOpListConst = *const LiteRtOpListT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtBuilderT {
    _unused: [u8; 0],
}
pub type LiteRtBuilder = *mut LiteRtBuilderT;
pub type LiteRtBuilderConst = *const LiteRtBuilderT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtOpaqueOptionsT {
    _unused: [u8; 0],
}
pub type LiteRtOpaqueOptions = *mut LiteRtOpaqueOptionsT;
pub type LiteRtOpaqueOptionsConst = *const LiteRtOpaqueOptionsT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtOptionsT {
    _unused: [u8; 0],
}
pub type LiteRtOptions = *mut LiteRtOptionsT;
pub type LiteRtOptionsConst = *const LiteRtOptionsT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtTensorBufferT {
    _unused: [u8; 0],
}
pub type LiteRtTensorBuffer = *mut LiteRtTensorBufferT;
pub type LiteRtTensorBufferConst = *const LiteRtTensorBufferT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtTensorBufferRequirementsT {
    _unused: [u8; 0],
}
pub type LiteRtTensorBufferRequirements = *mut LiteRtTensorBufferRequirementsT;
pub type LiteRtTensorBufferRequirementsConst = *const LiteRtTensorBufferRequirementsT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtProfilerT {
    _unused: [u8; 0],
}
pub type LiteRtProfiler = *mut LiteRtProfilerT;
pub type LiteRtProfilerConst = *const LiteRtProfilerT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtExternalLiteRtBufferContextT {
    _unused: [u8; 0],
}
pub type LiteRtExternalLiteRtBufferContext = *mut LiteRtExternalLiteRtBufferContextT;
pub type LiteRtExternalLiteRtBufferContextConst = *const LiteRtExternalLiteRtBufferContextT;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct LiteRtApiVersion {
    pub major: ::std::os::raw::c_int,
    pub minor: ::std::os::raw::c_int,
    pub patch: ::std::os::raw::c_int,
}
extern "C" {
    pub fn LiteRtCompareApiVersion(
        version: LiteRtApiVersion,
        reference: LiteRtApiVersion,
    ) -> ::std::os::raw::c_int;
}
pub const kLiteRtStatusOk: LiteRtStatus = 0;
pub const kLiteRtStatusErrorInvalidArgument: LiteRtStatus = 1;
pub const kLiteRtStatusErrorMemoryAllocationFailure: LiteRtStatus = 2;
pub const kLiteRtStatusErrorRuntimeFailure: LiteRtStatus = 3;
pub const kLiteRtStatusErrorMissingInputTensor: LiteRtStatus = 4;
pub const kLiteRtStatusErrorUnsupported: LiteRtStatus = 5;
pub const kLiteRtStatusErrorNotFound: LiteRtStatus = 6;
pub const kLiteRtStatusErrorTimeoutExpired: LiteRtStatus = 7;
pub const kLiteRtStatusErrorWrongVersion: LiteRtStatus = 8;
pub const kLiteRtStatusErrorUnknown: LiteRtStatus = 9;
pub const kLiteRtStatusErrorAlreadyExists: LiteRtStatus = 10;
pub const kLiteRtStatusCancelled: LiteRtStatus = 100;
pub const kLiteRtStatusErrorFileIO: LiteRtStatus = 500;
pub const kLiteRtStatusErrorInvalidFlatbuffer: LiteRtStatus = 501;
pub const kLiteRtStatusErrorDynamicLoading: LiteRtStatus = 502;
pub const kLiteRtStatusErrorSerialization: LiteRtStatus = 503;
pub const kLiteRtStatusErrorCompilation: LiteRtStatus = 504;
pub const kLiteRtStatusErrorIndexOOB: LiteRtStatus = 1000;
pub const kLiteRtStatusErrorInvalidIrType: LiteRtStatus = 1001;
pub const kLiteRtStatusErrorInvalidGraphInvariant: LiteRtStatus = 1002;
pub const kLiteRtStatusErrorGraphModification: LiteRtStatus = 1003;
pub const kLiteRtStatusErrorInvalidToolConfig: LiteRtStatus = 1500;
pub const kLiteRtStatusLegalizeNoMatch: LiteRtStatus = 2000;
pub const kLiteRtStatusErrorInvalidLegalization: LiteRtStatus = 2001;
pub const kLiteRtStatusPatternNoMatch: LiteRtStatus = 3000;
pub const kLiteRtStatusInvalidTransformation: LiteRtStatus = 3001;
pub const kLiteRtStatusErrorUnsupportedRuntimeVersion: LiteRtStatus = 4000;
pub const kLiteRtStatusErrorUnsupportedCompilerVersion: LiteRtStatus = 4001;
pub const kLiteRtStatusErrorIncompatibleByteCodeVersion: LiteRtStatus = 4002;
pub const kLiteRtStatusErrorUnsupportedOpShapeInferer: LiteRtStatus = 5000;
pub const kLiteRtStatusErrorShapeInferenceFailed: LiteRtStatus = 5001;
pub type LiteRtStatus = ::std::os::raw::c_uint;
extern "C" {
    pub fn LiteRtGetStatusString(status: LiteRtStatus) -> *const ::std::os::raw::c_char;
}
pub const kLiteRtHwAcceleratorNone: LiteRtHwAccelerators = 0;
pub const kLiteRtHwAcceleratorCpu: LiteRtHwAccelerators = 1;
pub const kLiteRtHwAcceleratorGpu: LiteRtHwAccelerators = 2;
pub const kLiteRtHwAcceleratorNpu: LiteRtHwAccelerators = 4;
pub type LiteRtHwAccelerators = ::std::os::raw::c_int;
pub const kLiteRtDelegatePrecisionDefault: LiteRtDelegatePrecision = 0;
pub const kLiteRtDelegatePrecisionFp16: LiteRtDelegatePrecision = 1;
pub const kLiteRtDelegatePrecisionFp32: LiteRtDelegatePrecision = 2;
pub type LiteRtDelegatePrecision = ::std::os::raw::c_uint;
pub const kLiteRtGpuPriorityDefault: LiteRtGpuPriority = 0;
pub const kLiteRtGpuPriorityLow: LiteRtGpuPriority = 1;
pub const kLiteRtGpuPriorityNormal: LiteRtGpuPriority = 2;
pub const kLiteRtGpuPriorityHigh: LiteRtGpuPriority = 3;
pub type LiteRtGpuPriority = ::std::os::raw::c_uint;
pub const kLiteRtDelegateBufferStorageTypeDefault: LiteRtDelegateBufferStorageType = 0;
pub const kLiteRtDelegateBufferStorageTypeBuffer: LiteRtDelegateBufferStorageType = 1;
pub const kLiteRtDelegateBufferStorageTypeTexture2D: LiteRtDelegateBufferStorageType = 2;
pub type LiteRtDelegateBufferStorageType = ::std::os::raw::c_uint;
pub const kLiteRtTensorBufferLockModeRead: LiteRtTensorBufferLockMode = 0;
pub const kLiteRtTensorBufferLockModeWrite: LiteRtTensorBufferLockMode = 1;
pub const kLiteRtTensorBufferLockModeReadWrite: LiteRtTensorBufferLockMode = 2;
pub type LiteRtTensorBufferLockMode = ::std::os::raw::c_uint;
pub const kLiteRtGpuBackendAutomatic: LiteRtGpuBackend = 0;
pub const kLiteRtGpuBackendOpenCl: LiteRtGpuBackend = 1;
pub const kLiteRtGpuBackendWebGpu: LiteRtGpuBackend = 2;
pub const kLiteRtGpuBackendOpenGl: LiteRtGpuBackend = 3;
pub type LiteRtGpuBackend = ::std::os::raw::c_uint;
pub const kLiteRtGpuWaitTypeDefault: LiteRtGpuWaitType = 0;
pub const kLiteRtGpuWaitTypePassive: LiteRtGpuWaitType = 1;
pub const kLiteRtGpuWaitTypeActive: LiteRtGpuWaitType = 2;
pub const kLiteRtGpuWaitTypeDoNotWait: LiteRtGpuWaitType = 3;
pub type LiteRtGpuWaitType = ::std::os::raw::c_uint;
pub const kLiteRtErrorReporterModeNone: LiteRtErrorReporterMode = 0;
pub const kLiteRtErrorReporterModeStderr: LiteRtErrorReporterMode = 1;
pub const kLiteRtErrorReporterModeBuffer: LiteRtErrorReporterMode = 2;
pub type LiteRtErrorReporterMode = ::std::os::raw::c_uint;
pub type LiteRtHwAcceleratorSet = ::std::os::raw::c_int;
pub type LiteRtParamIndex = usize;
pub const kLiteRtAnyTypeNone: LiteRtAnyType = 0;
pub const kLiteRtAnyTypeBool: LiteRtAnyType = 1;
pub const kLiteRtAnyTypeInt: LiteRtAnyType = 2;
pub const kLiteRtAnyTypeReal: LiteRtAnyType = 3;
pub const kLiteRtAnyTypeString: LiteRtAnyType = 8;
pub const kLiteRtAnyTypeVoidPtr: LiteRtAnyType = 9;
pub type LiteRtAnyType = ::std::os::raw::c_uint;
#[doc = " An object that holds various value type.\n\n @note This concrete type is part of the public API and is ABI stable."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct LiteRtAny {
    pub type_: LiteRtAnyType,
    pub __bindgen_anon_1: LiteRtAny__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union LiteRtAny__bindgen_ty_1 {
    pub bool_value: bool,
    pub int_value: i64,
    pub real_value: f64,
    pub str_value: *const ::std::os::raw::c_char,
    pub ptr_value: *const ::std::os::raw::c_void,
}
impl Default for LiteRtAny__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for LiteRtAny {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " The shape information for tensor types of fixed rank.\n\n @note This concrete type is part of the public API and is ABI stable."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct LiteRtLayout {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub dimensions: [i32; 8usize],
    pub strides: [u32; 8usize],
}
impl LiteRtLayout {
    #[inline]
    pub fn rank(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u32) }
    }
    #[inline]
    pub fn set_rank(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 7u8, val as u64)
        }
    }
    #[inline]
    pub fn has_strides(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_has_strides(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        rank: ::std::os::raw::c_uint,
        has_strides: bool,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 7u8, {
            let rank: u32 = unsafe { ::std::mem::transmute(rank) };
            rank as u64
        });
        __bindgen_bitfield_unit.set(7usize, 1u8, {
            let has_strides: u8 = unsafe { ::std::mem::transmute(has_strides) };
            has_strides as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    pub fn LiteRtGetNumLayoutElements(
        layout: *const LiteRtLayout,
        num_elements: *mut usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtIsSameLayout(
        layout1: *const LiteRtLayout,
        layout2: *const LiteRtLayout,
        result: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorName(
        tensor: LiteRtTensor,
        name: *mut *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorIndex(tensor: LiteRtTensor, tensor_index: *mut u32) -> LiteRtStatus;
}
pub const kLiteRtElementTypeNone: LiteRtElementType = 0;
pub const kLiteRtElementTypeBool: LiteRtElementType = 6;
pub const kLiteRtElementTypeInt2: LiteRtElementType = 20;
pub const kLiteRtElementTypeInt4: LiteRtElementType = 18;
pub const kLiteRtElementTypeInt8: LiteRtElementType = 9;
pub const kLiteRtElementTypeInt16: LiteRtElementType = 7;
pub const kLiteRtElementTypeInt32: LiteRtElementType = 2;
pub const kLiteRtElementTypeInt64: LiteRtElementType = 4;
pub const kLiteRtElementTypeUInt8: LiteRtElementType = 3;
pub const kLiteRtElementTypeUInt16: LiteRtElementType = 17;
pub const kLiteRtElementTypeUInt32: LiteRtElementType = 16;
pub const kLiteRtElementTypeUInt64: LiteRtElementType = 13;
pub const kLiteRtElementTypeFloat16: LiteRtElementType = 10;
pub const kLiteRtElementTypeBFloat16: LiteRtElementType = 19;
pub const kLiteRtElementTypeFloat32: LiteRtElementType = 1;
pub const kLiteRtElementTypeFloat64: LiteRtElementType = 11;
pub const kLiteRtElementTypeComplex64: LiteRtElementType = 8;
pub const kLiteRtElementTypeComplex128: LiteRtElementType = 12;
pub const kLiteRtElementTypeTfResource: LiteRtElementType = 14;
pub const kLiteRtElementTypeTfString: LiteRtElementType = 5;
pub const kLiteRtElementTypeTfVariant: LiteRtElementType = 15;
pub type LiteRtElementType = ::std::os::raw::c_uint;
#[doc = " Tensor type when its rank is dynamic.\n\n @note This concrete type is part of the public API and is ABI stable."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtUnrankedTensorType {
    pub element_type: LiteRtElementType,
}
impl Default for LiteRtUnrankedTensorType {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Tensor type when its rank is static but dimensions may be dynamic.\n\n @note This concrete type is part of the public API and is ABI stable."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtRankedTensorType {
    pub element_type: LiteRtElementType,
    pub layout: LiteRtLayout,
}
impl Default for LiteRtRankedTensorType {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const kLiteRtRankedTensorType: LiteRtTensorTypeId = 0;
pub const kLiteRtUnrankedTensorType: LiteRtTensorTypeId = 1;
pub type LiteRtTensorTypeId = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct LiteRtQuantizationPerTensor {
    pub scale: f32,
    pub zero_point: i64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtQuantizationPerChannel {
    pub quantized_dimension: i32,
    pub num_channels: u64,
    pub scales: *mut f32,
    pub zero_points: *mut i64,
}
impl Default for LiteRtQuantizationPerChannel {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const kLiteRtQuantizationNone: LiteRtQuantizationTypeId = 0;
pub const kLiteRtQuantizationPerTensor: LiteRtQuantizationTypeId = 1;
pub const kLiteRtQuantizationPerChannel: LiteRtQuantizationTypeId = 2;
pub const kLiteRtQuantizationBlockWise: LiteRtQuantizationTypeId = 3;
pub type LiteRtQuantizationTypeId = ::std::os::raw::c_uint;
extern "C" {
    pub fn LiteRtGetQuantizationTypeId(
        tensor: LiteRtTensor,
        q_type_id: *mut LiteRtQuantizationTypeId,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetPerTensorQuantization(
        tensor: LiteRtTensor,
        per_tensor_quantization: *mut LiteRtQuantizationPerTensor,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetPerChannelQuantization(
        tensor: LiteRtTensor,
        per_channel_quantization: *mut LiteRtQuantizationPerChannel,
    ) -> LiteRtStatus;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtTensorDefiningOp {
    pub op: LiteRtOp,
    pub op_output_index: LiteRtParamIndex,
}
impl Default for LiteRtTensorDefiningOp {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtTensorUserOp {
    pub op: LiteRtOp,
    pub op_input_index: LiteRtParamIndex,
}
impl Default for LiteRtTensorUserOp {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct LiteRtModelSerializationOptions {
    pub bytecode_alignment: usize,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AHardwareBuffer {
    _unused: [u8; 0],
}
pub type LiteRtHostMemoryDeallocator =
    ::std::option::Option<unsafe extern "C" fn(addr: *mut ::std::os::raw::c_void)>;
pub type LiteRtAhwbDeallocator =
    ::std::option::Option<unsafe extern "C" fn(ahwb: *mut AHardwareBuffer)>;
pub type LiteRtIonDeallocator =
    ::std::option::Option<unsafe extern "C" fn(ion_buffer_addr: *mut ::std::os::raw::c_void)>;
pub type LiteRtDmaBufDeallocator =
    ::std::option::Option<unsafe extern "C" fn(dmabuf_buffer_addr: *mut ::std::os::raw::c_void)>;
pub type LiteRtFastRpcDeallocator =
    ::std::option::Option<unsafe extern "C" fn(fastrpc_buffer_addr: *mut ::std::os::raw::c_void)>;
pub type LiteRtOpenClDeallocator =
    ::std::option::Option<unsafe extern "C" fn(opencl_buffer_addr: *mut ::std::os::raw::c_void)>;
pub type LiteRtGlBufferDeallocator =
    ::std::option::Option<unsafe extern "C" fn(gl_buffer_addr: *mut ::std::os::raw::c_void)>;
pub type LiteRtGlTextureDeallocator =
    ::std::option::Option<unsafe extern "C" fn(gl_texture_addr: *mut ::std::os::raw::c_void)>;
pub type LiteRtWebGpuBufferDeallocator =
    ::std::option::Option<unsafe extern "C" fn(webgpu_buffer_addr: *mut ::std::os::raw::c_void)>;
pub type LiteRtWebGpuTextureDeallocator =
    ::std::option::Option<unsafe extern "C" fn(webgpu_texture_addr: *mut ::std::os::raw::c_void)>;
pub type LiteRtMetalDeallocator =
    ::std::option::Option<unsafe extern "C" fn(metal_buffer_addr: *mut ::std::os::raw::c_void)>;
pub type LiteRtVulkanMemoryDeallocator =
    ::std::option::Option<unsafe extern "C" fn(vulkan_memory_addr: *mut ::std::os::raw::c_void)>;
pub const kLiteRtTensorBufferTypeUnknown: LiteRtTensorBufferType = 0;
pub const kLiteRtTensorBufferTypeHostMemory: LiteRtTensorBufferType = 1;
pub const kLiteRtTensorBufferTypeAhwb: LiteRtTensorBufferType = 2;
pub const kLiteRtTensorBufferTypeIon: LiteRtTensorBufferType = 3;
pub const kLiteRtTensorBufferTypeDmaBuf: LiteRtTensorBufferType = 4;
pub const kLiteRtTensorBufferTypeFastRpc: LiteRtTensorBufferType = 5;
pub const kLiteRtTensorBufferTypeGlBuffer: LiteRtTensorBufferType = 6;
pub const kLiteRtTensorBufferTypeGlTexture: LiteRtTensorBufferType = 7;
pub const kLiteRtTensorBufferTypeOpenClBuffer: LiteRtTensorBufferType = 10;
pub const kLiteRtTensorBufferTypeOpenClBufferFp16: LiteRtTensorBufferType = 11;
pub const kLiteRtTensorBufferTypeOpenClTexture: LiteRtTensorBufferType = 12;
pub const kLiteRtTensorBufferTypeOpenClTextureFp16: LiteRtTensorBufferType = 13;
pub const kLiteRtTensorBufferTypeOpenClBufferPacked: LiteRtTensorBufferType = 14;
pub const kLiteRtTensorBufferTypeOpenClImageBuffer: LiteRtTensorBufferType = 15;
pub const kLiteRtTensorBufferTypeOpenClImageBufferFp16: LiteRtTensorBufferType = 16;
pub const kLiteRtTensorBufferTypeWebGpuBuffer: LiteRtTensorBufferType = 20;
pub const kLiteRtTensorBufferTypeWebGpuBufferFp16: LiteRtTensorBufferType = 21;
pub const kLiteRtTensorBufferTypeWebGpuTexture: LiteRtTensorBufferType = 22;
pub const kLiteRtTensorBufferTypeWebGpuTextureFp16: LiteRtTensorBufferType = 23;
pub const kLiteRtTensorBufferTypeWebGpuImageBuffer: LiteRtTensorBufferType = 24;
pub const kLiteRtTensorBufferTypeWebGpuImageBufferFp16: LiteRtTensorBufferType = 25;
pub const kLiteRtTensorBufferTypeWebGpuBufferPacked: LiteRtTensorBufferType = 26;
pub const kLiteRtTensorBufferTypeMetalBuffer: LiteRtTensorBufferType = 30;
pub const kLiteRtTensorBufferTypeMetalBufferFp16: LiteRtTensorBufferType = 31;
pub const kLiteRtTensorBufferTypeMetalTexture: LiteRtTensorBufferType = 32;
pub const kLiteRtTensorBufferTypeMetalTextureFp16: LiteRtTensorBufferType = 33;
pub const kLiteRtTensorBufferTypeMetalBufferPacked: LiteRtTensorBufferType = 34;
pub const kLiteRtTensorBufferTypeVulkanBuffer: LiteRtTensorBufferType = 40;
pub const kLiteRtTensorBufferTypeVulkanBufferFp16: LiteRtTensorBufferType = 41;
pub const kLiteRtTensorBufferTypeVulkanTexture: LiteRtTensorBufferType = 42;
pub const kLiteRtTensorBufferTypeVulkanTextureFp16: LiteRtTensorBufferType = 43;
pub const kLiteRtTensorBufferTypeVulkanImageBuffer: LiteRtTensorBufferType = 44;
pub const kLiteRtTensorBufferTypeVulkanImageBufferFp16: LiteRtTensorBufferType = 45;
pub const kLiteRtTensorBufferTypeVulkanBufferPacked: LiteRtTensorBufferType = 46;
pub const kLiteRtTensorBufferTypeUserCustomBuffer: LiteRtTensorBufferType = 100;
pub const kLiteRtTensorBufferTypeOpenVINOTensorBuffer: LiteRtTensorBufferType = 100;
pub const kLiteRtTensorBufferTypeUserCustomBufferEnd: LiteRtTensorBufferType = 199;
pub type LiteRtTensorBufferType = ::std::os::raw::c_uint;
pub type LiteRtGpuDeviceId = *mut ::std::os::raw::c_void;
pub type LiteRtGpuQueueId = *mut ::std::os::raw::c_void;
pub type HwMemoryHandle = *mut ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct HwMemoryInfo {
    pub memory_handle: HwMemoryHandle,
    pub raw_handle: *mut ::std::os::raw::c_void,
}
impl Default for HwMemoryInfo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type HwMemoryInfoPtr = *mut HwMemoryInfo;
pub type CreateCustomTensorBuffer = ::std::option::Option<
    unsafe extern "C" fn(
        device_id: LiteRtGpuDeviceId,
        queue_id: LiteRtGpuQueueId,
        tensor_type: *const LiteRtRankedTensorType,
        buffer_type: LiteRtTensorBufferType,
        bytes: usize,
        packed_bytes: usize,
        hw_memory_info: *mut HwMemoryInfoPtr,
    ) -> LiteRtStatus,
>;
pub type ImportCustomTensorBuffer = ::std::option::Option<
    unsafe extern "C" fn(
        device_id: LiteRtGpuDeviceId,
        queue_id: LiteRtGpuQueueId,
        tensor_type: *const LiteRtRankedTensorType,
        buffer_type: LiteRtTensorBufferType,
        hw_buffer_handle: HwMemoryHandle,
        bytes: usize,
        packed_bytes: usize,
        hw_memory_info: *mut HwMemoryInfoPtr,
    ) -> LiteRtStatus,
>;
pub type DestroyCustomTensorBuffer =
    ::std::option::Option<unsafe extern "C" fn(hw_memory_info: HwMemoryInfoPtr) -> LiteRtStatus>;
pub type LockCustomTensorBuffer = ::std::option::Option<
    unsafe extern "C" fn(
        hw_memory_info: HwMemoryInfoPtr,
        mode: LiteRtTensorBufferLockMode,
        host_memory_ptr: *mut *mut ::std::os::raw::c_void,
    ) -> LiteRtStatus,
>;
pub type UnlockCustomTensorBuffer =
    ::std::option::Option<unsafe extern "C" fn(hw_memory_info: HwMemoryInfoPtr) -> LiteRtStatus>;
pub type ClearCustomTensorBuffer =
    ::std::option::Option<unsafe extern "C" fn(hw_memory_info: HwMemoryInfoPtr) -> LiteRtStatus>;
pub const kLiteRtEnvOptionTagCompilerPluginLibraryDir: LiteRtEnvOptionTag = 0;
pub const kLiteRtEnvOptionTagDispatchLibraryDir: LiteRtEnvOptionTag = 1;
pub const kLiteRtEnvOptionTagOpenClDeviceId: LiteRtEnvOptionTag = 2;
pub const kLiteRtEnvOptionTagOpenClPlatformId: LiteRtEnvOptionTag = 3;
pub const kLiteRtEnvOptionTagOpenClContext: LiteRtEnvOptionTag = 4;
pub const kLiteRtEnvOptionTagOpenClCommandQueue: LiteRtEnvOptionTag = 5;
pub const kLiteRtEnvOptionTagEglDisplay: LiteRtEnvOptionTag = 6;
pub const kLiteRtEnvOptionTagEglContext: LiteRtEnvOptionTag = 7;
pub const kLiteRtEnvOptionTagWebGpuDevice: LiteRtEnvOptionTag = 8;
pub const kLiteRtEnvOptionTagWebGpuQueue: LiteRtEnvOptionTag = 9;
pub const kLiteRtEnvOptionTagMetalDevice: LiteRtEnvOptionTag = 10;
pub const kLiteRtEnvOptionTagMetalCommandQueue: LiteRtEnvOptionTag = 11;
pub const kLiteRtEnvOptionTagVulkanEnvironment: LiteRtEnvOptionTag = 12;
pub const kLiteRtEnvOptionTagCallbackOnGpuEnvDestroy: LiteRtEnvOptionTag = 14;
pub const kLiteRtEnvOptionTagCallbackUserDataOnGpuEnvDestroy: LiteRtEnvOptionTag = 15;
pub const kLiteRtEnvOptionTagMagicNumberConfigs: LiteRtEnvOptionTag = 16;
pub const kLiteRtEnvOptionTagMagicNumberVerifications: LiteRtEnvOptionTag = 17;
pub const kLiteRtEnvOptionTagCompilerCacheDir: LiteRtEnvOptionTag = 18;
pub const kLiteRtEnvOptionTagWebGpuInstance: LiteRtEnvOptionTag = 19;
pub const kLiteRtEnvOptionTagWebGpuProcs: LiteRtEnvOptionTag = 20;
pub const kLiteRtEnvOptionTagCustomTensorBufferHandlers_deprecated: LiteRtEnvOptionTag = 21;
pub const kLiteRtEnvOptionTagRuntimeLibraryDir: LiteRtEnvOptionTag = 22;
#[doc = " \\internal This is for internal use only, for a custom runtime."]
pub const kLiteRtEnvOptionTagSystemRuntimeHandle: LiteRtEnvOptionTag = 23;
#[doc = " \\internal This is for internal use only, for a custom runtime."]
pub const kLiteRtEnvOptionTagAutoRegisterAccelerators: LiteRtEnvOptionTag = 24;
#[doc = " \\internal This is for internal use only, for a custom runtime."]
pub const kLiteRtEnvOptionTagMinLoggerSeverity: LiteRtEnvOptionTag = 25;
#[doc = " \\internal This is for internal use only, for a custom runtime."]
pub const kLiteRtEnvOptionTagNull: LiteRtEnvOptionTag = 255;
pub type LiteRtEnvOptionTag = ::std::os::raw::c_uint;
#[doc = " An object that holds option data for the LiteRtEnvironment.\n\n @note This concrete type is part of the public API and is ABI stable."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct LiteRtEnvOption {
    pub tag: LiteRtEnvOptionTag,
    pub value: LiteRtAny,
}
impl Default for LiteRtEnvOption {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtMagicNumberConfig {
    pub magic_number: i64,
    pub target_number: i64,
    pub signature_prefix: *const ::std::os::raw::c_char,
}
impl Default for LiteRtMagicNumberConfig {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct LiteRtMagicNumberConfigs {
    pub num_configs: i64,
    pub configs: __IncompleteArrayField<LiteRtMagicNumberConfig>,
}
impl Default for LiteRtMagicNumberConfigs {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtMagicNumberVerification {
    pub signature: *const ::std::os::raw::c_char,
    pub test_signature: *const ::std::os::raw::c_char,
    pub is_superset: bool,
}
impl Default for LiteRtMagicNumberVerification {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug)]
pub struct LiteRtMagicNumberVerifications {
    pub num_verifications: i64,
    pub verifications: __IncompleteArrayField<LiteRtMagicNumberVerification>,
}
impl Default for LiteRtMagicNumberVerifications {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct LiteRtCustomTensorBufferHandlers {
    pub create_func: CreateCustomTensorBuffer,
    pub destroy_func: DestroyCustomTensorBuffer,
    pub lock_func: LockCustomTensorBuffer,
    pub unlock_func: UnlockCustomTensorBuffer,
    pub clear_func: ClearCustomTensorBuffer,
    pub import_func: ImportCustomTensorBuffer,
}
extern "C" {
    pub fn LiteRtGetEnvironmentOptionsValue(
        options: LiteRtEnvironmentOptions,
        tag: LiteRtEnvOptionTag,
        value: *mut LiteRtAny,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtSetEnvironmentOptionsValue(
        options: LiteRtEnvironmentOptions,
        env_option: LiteRtEnvOption,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateEnvironment(
        num_options: ::std::os::raw::c_int,
        options: *const LiteRtEnvOption,
        environment: *mut LiteRtEnvironment,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDestroyEnvironment(environment: LiteRtEnvironment);
}
extern "C" {
    pub fn LiteRtGetEnvironmentOptions(
        environment: LiteRtEnvironment,
        options: *mut LiteRtEnvironmentOptions,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtAddEnvironmentOptions(
        environment: LiteRtEnvironment,
        num_options: ::std::os::raw::c_int,
        options: *const LiteRtEnvOption,
        overwrite: bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGpuEnvironmentCreate(
        environment: LiteRtEnvironment,
        num_options: ::std::os::raw::c_int,
        options: *const LiteRtEnvOption,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtEnvironmentSupportsClGlInterop(
        environment: LiteRtEnvironment,
        is_supported: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtEnvironmentSupportsAhwbClInterop(
        environment: LiteRtEnvironment,
        is_supported: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtEnvironmentSupportsAhwbGlInterop(
        environment: LiteRtEnvironment,
        is_supported: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtEnvironmentHasGpuEnvironment(
        environment: LiteRtEnvironment,
        has_gpu_environment: *mut bool,
    );
}
extern "C" {
    pub fn LiteRtCreateOpaqueOptions(
        payload_identifier: *const ::std::os::raw::c_char,
        payload_data: *mut ::std::os::raw::c_void,
        payload_destructor: ::std::option::Option<
            unsafe extern "C" fn(payload_data: *mut ::std::os::raw::c_void),
        >,
        options: *mut LiteRtOpaqueOptions,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDestroyOpaqueOptions(options: LiteRtOpaqueOptions);
}
extern "C" {
    pub fn LiteRtGetOpaqueOptionsIdentifier(
        options: LiteRtOpaqueOptions,
        payload_identifier: *mut *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetOpaqueOptionsData(
        options: LiteRtOpaqueOptions,
        payload_data: *mut *mut ::std::os::raw::c_void,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtFindOpaqueOptionsData(
        options: LiteRtOpaqueOptions,
        payload_identifier: *const ::std::os::raw::c_char,
        payload_data: *mut *mut ::std::os::raw::c_void,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNextOpaqueOptions(options: *mut LiteRtOpaqueOptions) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtAppendOpaqueOptions(
        options: *mut LiteRtOpaqueOptions,
        appended_options: LiteRtOpaqueOptions,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtPopOpaqueOptions(options: *mut LiteRtOpaqueOptions) -> LiteRtStatus;
}
pub type LiteRtOpaqueOptionsHashFunc =
    ::std::option::Option<unsafe extern "C" fn(payload_data: *const ::std::os::raw::c_void) -> u64>;
extern "C" {
    pub fn LiteRtSetOpaqueOptionsHash(
        options: LiteRtOpaqueOptions,
        payload_hash_func: LiteRtOpaqueOptionsHashFunc,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetOpaqueOptionsHash(options: LiteRtOpaqueOptions, hash: *mut u64)
        -> LiteRtStatus;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct LiteRtCustomOpKernel {
    pub Init: ::std::option::Option<
        unsafe extern "C" fn(
            user_data: *mut ::std::os::raw::c_void,
            init_data: *const ::std::os::raw::c_void,
            init_data_size: usize,
        ) -> LiteRtStatus,
    >,
    pub GetOutputLayouts: ::std::option::Option<
        unsafe extern "C" fn(
            user_data: *mut ::std::os::raw::c_void,
            num_inputs: usize,
            input_layouts: *const LiteRtLayout,
            num_outputs: usize,
            output_layouts: *mut LiteRtLayout,
        ) -> LiteRtStatus,
    >,
    pub Run: ::std::option::Option<
        unsafe extern "C" fn(
            user_data: *mut ::std::os::raw::c_void,
            num_inputs: usize,
            inputs: *const LiteRtTensorBuffer,
            num_outputs: usize,
            outputs: *mut LiteRtTensorBuffer,
        ) -> LiteRtStatus,
    >,
    pub Destroy: ::std::option::Option<
        unsafe extern "C" fn(user_data: *mut ::std::os::raw::c_void) -> LiteRtStatus,
    >,
}
extern "C" {
    pub fn LiteRtCreateOptions(options: *mut LiteRtOptions) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDestroyOptions(options: LiteRtOptions);
}
extern "C" {
    pub fn LiteRtSetOptionsHardwareAccelerators(
        options: LiteRtOptions,
        hardware_accelerators: LiteRtHwAcceleratorSet,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetOptionsHardwareAccelerators(
        options: LiteRtOptions,
        hardware_accelerators: *mut LiteRtHwAcceleratorSet,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtAddOpaqueOptions(
        options: LiteRtOptions,
        opaque_options: LiteRtOpaqueOptions,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetOpaqueOptions(
        options: LiteRtOptions,
        opaque_options: *mut LiteRtOpaqueOptions,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtAddCustomOpKernelOption(
        options: LiteRtOptions,
        custom_op_name: *const ::std::os::raw::c_char,
        custom_op_version: ::std::os::raw::c_int,
        custom_op_kernel: *const LiteRtCustomOpKernel,
        custom_op_kernel_user_data: *mut ::std::os::raw::c_void,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtAddExternalTensorBinding(
        options: LiteRtOptions,
        signature_name: *const ::std::os::raw::c_char,
        tensor_name: *const ::std::os::raw::c_char,
        data: *mut ::std::os::raw::c_void,
        size_bytes: ::std::os::raw::c_int,
    ) -> LiteRtStatus;
}
pub const kLiteRtOpCodeTflAdd: LiteRtOpCode = 0;
pub const kLiteRtOpCodeTflAveragePool2d: LiteRtOpCode = 1;
pub const kLiteRtOpCodeTflConcatenation: LiteRtOpCode = 2;
pub const kLiteRtOpCodeTflConv2d: LiteRtOpCode = 3;
pub const kLiteRtOpCodeTflDepthwiseConv2d: LiteRtOpCode = 4;
pub const kLiteRtOpCodeTflDepthToSpace: LiteRtOpCode = 5;
pub const kLiteRtOpCodeTflDequantize: LiteRtOpCode = 6;
pub const kLiteRtOpCodeTflEmbeddingLookup: LiteRtOpCode = 7;
pub const kLiteRtOpCodeTflFloor: LiteRtOpCode = 8;
pub const kLiteRtOpCodeTflFullyConnected: LiteRtOpCode = 9;
pub const kLiteRtOpCodeTflHashtableLookup: LiteRtOpCode = 10;
pub const kLiteRtOpCodeTflL2Normalization: LiteRtOpCode = 11;
pub const kLiteRtOpCodeTflL2Pool2d: LiteRtOpCode = 12;
pub const kLiteRtOpCodeTflLocalResponseNormalization: LiteRtOpCode = 13;
pub const kLiteRtOpCodeTflLogistic: LiteRtOpCode = 14;
pub const kLiteRtOpCodeTflLshProjection: LiteRtOpCode = 15;
pub const kLiteRtOpCodeTflLstm: LiteRtOpCode = 16;
pub const kLiteRtOpCodeTflMaxPool2d: LiteRtOpCode = 17;
pub const kLiteRtOpCodeTflMul: LiteRtOpCode = 18;
pub const kLiteRtOpCodeTflRelu: LiteRtOpCode = 19;
pub const kLiteRtOpCodeTflReluN1To1: LiteRtOpCode = 20;
pub const kLiteRtOpCodeTflRelu6: LiteRtOpCode = 21;
pub const kLiteRtOpCodeTflReshape: LiteRtOpCode = 22;
pub const kLiteRtOpCodeTflResizeBilinear: LiteRtOpCode = 23;
pub const kLiteRtOpCodeTflRnn: LiteRtOpCode = 24;
pub const kLiteRtOpCodeTflSoftmax: LiteRtOpCode = 25;
pub const kLiteRtOpCodeTflSpaceToDepth: LiteRtOpCode = 26;
pub const kLiteRtOpCodeTflSvdf: LiteRtOpCode = 27;
pub const kLiteRtOpCodeTflTanh: LiteRtOpCode = 28;
pub const kLiteRtOpCodeTflConcatEmbeddings: LiteRtOpCode = 29;
pub const kLiteRtOpCodeTflSkipGram: LiteRtOpCode = 30;
pub const kLiteRtOpCodeTflCall: LiteRtOpCode = 31;
pub const kLiteRtOpCodeTflCustom: LiteRtOpCode = 32;
pub const kLiteRtOpCodeTflEmbeddingLookupSparse: LiteRtOpCode = 33;
pub const kLiteRtOpCodeTflPad: LiteRtOpCode = 34;
pub const kLiteRtOpCodeTflUnidirectionalSequenceRnn: LiteRtOpCode = 35;
pub const kLiteRtOpCodeTflGather: LiteRtOpCode = 36;
pub const kLiteRtOpCodeTflBatchToSpaceNd: LiteRtOpCode = 37;
pub const kLiteRtOpCodeTflSpaceToBatchNd: LiteRtOpCode = 38;
pub const kLiteRtOpCodeTflTranspose: LiteRtOpCode = 39;
pub const kLiteRtOpCodeTflMean: LiteRtOpCode = 40;
pub const kLiteRtOpCodeTflSub: LiteRtOpCode = 41;
pub const kLiteRtOpCodeTflDiv: LiteRtOpCode = 42;
pub const kLiteRtOpCodeTflSqueeze: LiteRtOpCode = 43;
pub const kLiteRtOpCodeTflUnidirectionalSequenceLstm: LiteRtOpCode = 44;
pub const kLiteRtOpCodeTflStridedSlice: LiteRtOpCode = 45;
pub const kLiteRtOpCodeTflBidirectionalSequenceRnn: LiteRtOpCode = 46;
pub const kLiteRtOpCodeTflExp: LiteRtOpCode = 47;
pub const kLiteRtOpCodeTflTopkV2: LiteRtOpCode = 48;
pub const kLiteRtOpCodeTflSplit: LiteRtOpCode = 49;
pub const kLiteRtOpCodeTflLogSoftmax: LiteRtOpCode = 50;
pub const kLiteRtOpCodeTflDelegate: LiteRtOpCode = 51;
pub const kLiteRtOpCodeTflBidirectionalSequenceLstm: LiteRtOpCode = 52;
pub const kLiteRtOpCodeTflCast: LiteRtOpCode = 53;
pub const kLiteRtOpCodeTflPrelu: LiteRtOpCode = 54;
pub const kLiteRtOpCodeTflMaximum: LiteRtOpCode = 55;
pub const kLiteRtOpCodeTflArgMax: LiteRtOpCode = 56;
pub const kLiteRtOpCodeTflMinimum: LiteRtOpCode = 57;
pub const kLiteRtOpCodeTflLess: LiteRtOpCode = 58;
pub const kLiteRtOpCodeTflNeg: LiteRtOpCode = 59;
pub const kLiteRtOpCodeTflPadv2: LiteRtOpCode = 60;
pub const kLiteRtOpCodeTflGreater: LiteRtOpCode = 61;
pub const kLiteRtOpCodeTflGreaterEqual: LiteRtOpCode = 62;
pub const kLiteRtOpCodeTflLessEqual: LiteRtOpCode = 63;
pub const kLiteRtOpCodeTflSelect: LiteRtOpCode = 64;
pub const kLiteRtOpCodeTflSlice: LiteRtOpCode = 65;
pub const kLiteRtOpCodeTflSin: LiteRtOpCode = 66;
pub const kLiteRtOpCodeTflTransposeConv: LiteRtOpCode = 67;
pub const kLiteRtOpCodeTflSparseToDense: LiteRtOpCode = 68;
pub const kLiteRtOpCodeTflTile: LiteRtOpCode = 69;
pub const kLiteRtOpCodeTflExpandDims: LiteRtOpCode = 70;
pub const kLiteRtOpCodeTflEqual: LiteRtOpCode = 71;
pub const kLiteRtOpCodeTflNotEqual: LiteRtOpCode = 72;
pub const kLiteRtOpCodeTflLog: LiteRtOpCode = 73;
pub const kLiteRtOpCodeTflSum: LiteRtOpCode = 74;
pub const kLiteRtOpCodeTflSqrt: LiteRtOpCode = 75;
pub const kLiteRtOpCodeTflRsqrt: LiteRtOpCode = 76;
pub const kLiteRtOpCodeTflShape: LiteRtOpCode = 77;
pub const kLiteRtOpCodeTflPow: LiteRtOpCode = 78;
pub const kLiteRtOpCodeTflArgMin: LiteRtOpCode = 79;
pub const kLiteRtOpCodeTflFakeQuant: LiteRtOpCode = 80;
pub const kLiteRtOpCodeTflReduceProd: LiteRtOpCode = 81;
pub const kLiteRtOpCodeTflReduceMax: LiteRtOpCode = 82;
pub const kLiteRtOpCodeTflPack: LiteRtOpCode = 83;
pub const kLiteRtOpCodeTflLogicalOr: LiteRtOpCode = 84;
pub const kLiteRtOpCodeTflOneHot: LiteRtOpCode = 85;
pub const kLiteRtOpCodeTflLogicalAnd: LiteRtOpCode = 86;
pub const kLiteRtOpCodeTflLogicalNot: LiteRtOpCode = 87;
pub const kLiteRtOpCodeTflUnpack: LiteRtOpCode = 88;
pub const kLiteRtOpCodeTflReduceMin: LiteRtOpCode = 89;
pub const kLiteRtOpCodeTflFloorDiv: LiteRtOpCode = 90;
pub const kLiteRtOpCodeTflReduceAny: LiteRtOpCode = 91;
pub const kLiteRtOpCodeTflSquare: LiteRtOpCode = 92;
pub const kLiteRtOpCodeTflZerosLike: LiteRtOpCode = 93;
pub const kLiteRtOpCodeTflFill: LiteRtOpCode = 94;
pub const kLiteRtOpCodeTflFloorMod: LiteRtOpCode = 95;
pub const kLiteRtOpCodeTflRange: LiteRtOpCode = 96;
pub const kLiteRtOpCodeTflResizeNearestNeighbor: LiteRtOpCode = 97;
pub const kLiteRtOpCodeTflLeakyRelu: LiteRtOpCode = 98;
pub const kLiteRtOpCodeTflSquaredDifference: LiteRtOpCode = 99;
pub const kLiteRtOpCodeTflMirrorPad: LiteRtOpCode = 100;
pub const kLiteRtOpCodeTflAbs: LiteRtOpCode = 101;
pub const kLiteRtOpCodeTflSplitV: LiteRtOpCode = 102;
pub const kLiteRtOpCodeTflUnique: LiteRtOpCode = 103;
pub const kLiteRtOpCodeTflCeil: LiteRtOpCode = 104;
pub const kLiteRtOpCodeTflReverseV2: LiteRtOpCode = 105;
pub const kLiteRtOpCodeTflAddN: LiteRtOpCode = 106;
pub const kLiteRtOpCodeTflGatherNd: LiteRtOpCode = 107;
pub const kLiteRtOpCodeTflCos: LiteRtOpCode = 108;
pub const kLiteRtOpCodeTflWhere: LiteRtOpCode = 109;
pub const kLiteRtOpCodeTflRank: LiteRtOpCode = 110;
pub const kLiteRtOpCodeTflElu: LiteRtOpCode = 111;
pub const kLiteRtOpCodeTflReverseSequence: LiteRtOpCode = 112;
pub const kLiteRtOpCodeTflMatrixDiag: LiteRtOpCode = 113;
pub const kLiteRtOpCodeTflQuantize: LiteRtOpCode = 114;
pub const kLiteRtOpCodeTflMatrixSetDiag: LiteRtOpCode = 115;
pub const kLiteRtOpCodeTflRound: LiteRtOpCode = 116;
pub const kLiteRtOpCodeTflHardSwish: LiteRtOpCode = 117;
pub const kLiteRtOpCodeTflIf: LiteRtOpCode = 118;
pub const kLiteRtOpCodeTflWhile: LiteRtOpCode = 119;
pub const kLiteRtOpCodeTflNonMaxSuppressionV4: LiteRtOpCode = 120;
pub const kLiteRtOpCodeTflNonMaxSuppressionV5: LiteRtOpCode = 121;
pub const kLiteRtOpCodeTflScatterNd: LiteRtOpCode = 122;
pub const kLiteRtOpCodeTflSelectV2: LiteRtOpCode = 123;
pub const kLiteRtOpCodeTflDensify: LiteRtOpCode = 124;
pub const kLiteRtOpCodeTflSegmentSum: LiteRtOpCode = 125;
pub const kLiteRtOpCodeTflBatchMatmul: LiteRtOpCode = 126;
pub const kLiteRtOpCodeTflPlaceholderForGreaterOpCodeTfls: LiteRtOpCode = 127;
pub const kLiteRtOpCodeTflCumsum: LiteRtOpCode = 128;
pub const kLiteRtOpCodeTflCallOnce: LiteRtOpCode = 129;
pub const kLiteRtOpCodeTflBroadcastTo: LiteRtOpCode = 130;
pub const kLiteRtOpCodeTflRfft2d: LiteRtOpCode = 131;
pub const kLiteRtOpCodeTflConv3d: LiteRtOpCode = 132;
pub const kLiteRtOpCodeTflImag: LiteRtOpCode = 133;
pub const kLiteRtOpCodeTflReal: LiteRtOpCode = 134;
pub const kLiteRtOpCodeTflComplexAbs: LiteRtOpCode = 135;
pub const kLiteRtOpCodeTflHashtable: LiteRtOpCode = 136;
pub const kLiteRtOpCodeTflHashtableFind: LiteRtOpCode = 137;
pub const kLiteRtOpCodeTflHashtableImport: LiteRtOpCode = 138;
pub const kLiteRtOpCodeTflHashtableSize: LiteRtOpCode = 139;
pub const kLiteRtOpCodeTflReduceAll: LiteRtOpCode = 140;
pub const kLiteRtOpCodeTflConv3dTranspose: LiteRtOpCode = 141;
pub const kLiteRtOpCodeTflVarHandle: LiteRtOpCode = 142;
pub const kLiteRtOpCodeTflReadVariable: LiteRtOpCode = 143;
pub const kLiteRtOpCodeTflAssignVariable: LiteRtOpCode = 144;
pub const kLiteRtOpCodeTflBroadcastArgs: LiteRtOpCode = 145;
pub const kLiteRtOpCodeTflRandomStandardNormal: LiteRtOpCode = 146;
pub const kLiteRtOpCodeTflBucketize: LiteRtOpCode = 147;
pub const kLiteRtOpCodeTflRandomUniform: LiteRtOpCode = 148;
pub const kLiteRtOpCodeTflMultinomial: LiteRtOpCode = 149;
pub const kLiteRtOpCodeTflGelu: LiteRtOpCode = 150;
pub const kLiteRtOpCodeTflDynamicUpdateSlice: LiteRtOpCode = 151;
pub const kLiteRtOpCodeTflRelu0To1: LiteRtOpCode = 152;
pub const kLiteRtOpCodeTflUnsortedSegmentProd: LiteRtOpCode = 153;
pub const kLiteRtOpCodeTflUnsortedSegmentMax: LiteRtOpCode = 154;
pub const kLiteRtOpCodeTflUnsortedSegmentSum: LiteRtOpCode = 155;
pub const kLiteRtOpCodeTflAtan2: LiteRtOpCode = 156;
pub const kLiteRtOpCodeTflUnsortedSegmentMin: LiteRtOpCode = 157;
pub const kLiteRtOpCodeTflSign: LiteRtOpCode = 158;
pub const kLiteRtOpCodeTflBitcast: LiteRtOpCode = 159;
pub const kLiteRtOpCodeTflBitwiseXor: LiteRtOpCode = 160;
pub const kLiteRtOpCodeTflRightShift: LiteRtOpCode = 161;
pub const kLiteRtOpCodeShloLogistic: LiteRtOpCode = 162;
pub const kLiteRtOpCodeShloAdd: LiteRtOpCode = 163;
pub const kLiteRtOpCodeShloDivide: LiteRtOpCode = 164;
pub const kLiteRtOpCodeShloMultiply: LiteRtOpCode = 165;
pub const kLiteRtOpCodeShloMaximum: LiteRtOpCode = 166;
pub const kLiteRtOpCodeShloReshape: LiteRtOpCode = 167;
pub const kLiteRtOpCodeShloClamp: LiteRtOpCode = 168;
pub const kLiteRtOpCodeShloConcatenate: LiteRtOpCode = 169;
pub const kLiteRtOpCodeShloBroadcastInDim: LiteRtOpCode = 170;
pub const kLiteRtOpCodeShloConvolution: LiteRtOpCode = 171;
pub const kLiteRtOpCodeShloSlice: LiteRtOpCode = 172;
pub const kLiteRtOpCodeShloCustomCall: LiteRtOpCode = 173;
pub const kLiteRtOpCodeShloReduce: LiteRtOpCode = 174;
pub const kLiteRtOpCodeShloAbs: LiteRtOpCode = 175;
pub const kLiteRtOpCodeShloAnd: LiteRtOpCode = 176;
pub const kLiteRtOpCodeShloCosine: LiteRtOpCode = 177;
pub const kLiteRtOpCodeShloExponential: LiteRtOpCode = 178;
pub const kLiteRtOpCodeShloFloor: LiteRtOpCode = 179;
pub const kLiteRtOpCodeShloLog: LiteRtOpCode = 180;
pub const kLiteRtOpCodeShloMinimum: LiteRtOpCode = 181;
pub const kLiteRtOpCodeShloNegate: LiteRtOpCode = 182;
pub const kLiteRtOpCodeShloOr: LiteRtOpCode = 183;
pub const kLiteRtOpCodeShloPower: LiteRtOpCode = 184;
pub const kLiteRtOpCodeShloRemainder: LiteRtOpCode = 185;
pub const kLiteRtOpCodeShloRsqrt: LiteRtOpCode = 186;
pub const kLiteRtOpCodeShloSelect: LiteRtOpCode = 187;
pub const kLiteRtOpCodeShloSubtract: LiteRtOpCode = 188;
pub const kLiteRtOpCodeShloTanh: LiteRtOpCode = 189;
pub const kLiteRtOpCodeShloScatter: LiteRtOpCode = 190;
pub const kLiteRtOpCodeShloCompare: LiteRtOpCode = 191;
pub const kLiteRtOpCodeShloConvert: LiteRtOpCode = 192;
pub const kLiteRtOpCodeShloDynamicSlice: LiteRtOpCode = 193;
pub const kLiteRtOpCodeShloDynamicUpdateSlice: LiteRtOpCode = 194;
pub const kLiteRtOpCodeShloPad: LiteRtOpCode = 195;
pub const kLiteRtOpCodeShloIota: LiteRtOpCode = 196;
pub const kLiteRtOpCodeShloGeneral: LiteRtOpCode = 197;
pub const kLiteRtOpCodeShloWindow: LiteRtOpCode = 198;
pub const kLiteRtOpCodeShloSort: LiteRtOpCode = 199;
pub const kLiteRtOpCodeShloWhile: LiteRtOpCode = 200;
pub const kLiteRtOpCodeShloGather: LiteRtOpCode = 201;
pub const kLiteRtOpCodeShloTranspose: LiteRtOpCode = 202;
pub const kLiteRtOpCodeTflDilate: LiteRtOpCode = 203;
pub const kLiteRtOpCodeShloRngBitGenerator: LiteRtOpCode = 204;
pub const kLiteRtOpCodeTflReduceWindow: LiteRtOpCode = 205;
pub const kLiteRtOpCodeShloComposite: LiteRtOpCode = 206;
pub type LiteRtOpCode = ::std::os::raw::c_uint;
extern "C" {
    pub fn LiteRtGetTensorTypeId(
        tensor: LiteRtTensor,
        type_id: *mut LiteRtTensorTypeId,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetUnrankedTensorType(
        tensor: LiteRtTensor,
        unranked_tensor_type: *mut LiteRtUnrankedTensorType,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetRankedTensorType(
        tensor: LiteRtTensor,
        ranked_tensor_type: *mut LiteRtRankedTensorType,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumTensorUses(
        tensor: LiteRtTensor,
        num_uses: *mut LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorUse(
        tensor: LiteRtTensor,
        use_index: LiteRtParamIndex,
        user: *mut LiteRtOp,
        user_arg_index: *mut LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorDefiningOp(
        tensor: LiteRtTensor,
        has_defining_op: *mut bool,
        defining_op: *mut LiteRtTensorDefiningOp,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorWeights(
        tensor: LiteRtTensor,
        weights: *mut LiteRtWeights,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetWeightsBytes(
        weights: LiteRtWeights,
        addr: *mut *const ::std::os::raw::c_void,
        size: *mut usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetWeightsBufferId(weights: LiteRtWeights, buffer_id: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetOpCode(op: LiteRtOp, code: *mut LiteRtOpCode) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetCustomCode(
        op: LiteRtOp,
        code: *mut *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumOpInputs(op: LiteRtOp, num_inputs: *mut LiteRtParamIndex) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetOpInput(
        op: LiteRtOp,
        input_index: LiteRtParamIndex,
        input: *mut LiteRtTensor,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumOpOutputs(op: LiteRtOp, num_outputs: *mut LiteRtParamIndex) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetOpOutput(
        op: LiteRtOp,
        output_index: LiteRtParamIndex,
        output: *mut LiteRtTensor,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumSubgraphInputs(
        subgraph: LiteRtSubgraph,
        num_inputs: *mut LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSubgraphInput(
        subgraph: LiteRtSubgraph,
        input_index: LiteRtParamIndex,
        input: *mut LiteRtTensor,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumSubgraphOutputs(
        subgraph: LiteRtSubgraph,
        num_outputs: *mut LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSubgraphOutput(
        subgraph: LiteRtSubgraph,
        output_index: LiteRtParamIndex,
        output: *mut LiteRtTensor,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumSubgraphOps(
        subgraph: LiteRtSubgraph,
        num_ops: *mut LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSubgraphOp(
        subgraph: LiteRtSubgraph,
        op_index: LiteRtParamIndex,
        op: *mut LiteRtOp,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSignatureKey(
        signature: LiteRtSignature,
        signature_key: *mut *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSignatureSubgraph(
        signature: LiteRtSignature,
        subgraph: *mut LiteRtSubgraph,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumSignatureInputs(
        signature: LiteRtSignature,
        num_inputs: *mut LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSignatureInputName(
        signature: LiteRtSignature,
        input_idx: LiteRtParamIndex,
        input_name: *mut *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSignatureInputTensor(
        signature: LiteRtSignature,
        input_name: *const ::std::os::raw::c_char,
        tensor: *mut LiteRtTensor,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSignatureInputTensorByIndex(
        signature: LiteRtSignature,
        input_idx: LiteRtParamIndex,
        tensor: *mut LiteRtTensor,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumSignatureOutputs(
        signature: LiteRtSignature,
        num_outputs: *mut LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSignatureOutputName(
        signature: LiteRtSignature,
        output_idx: LiteRtParamIndex,
        output_name: *mut *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSignatureOutputTensor(
        signature: LiteRtSignature,
        output_name: *const ::std::os::raw::c_char,
        tensor: *mut LiteRtTensor,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSignatureOutputTensorByIndex(
        signature: LiteRtSignature,
        output_idx: LiteRtParamIndex,
        tensor: *mut LiteRtTensor,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateModelFromFile(
        filename: *const ::std::os::raw::c_char,
        model: *mut LiteRtModel,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateModelFromBuffer(
        buffer_addr: *const ::std::os::raw::c_void,
        buffer_size: usize,
        model: *mut LiteRtModel,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetModelMetadata(
        model: LiteRtModel,
        metadata_key: *const ::std::os::raw::c_char,
        metadata_buffer: *mut *const ::std::os::raw::c_void,
        metadata_buffer_size: *mut usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtAddModelMetadata(
        model: LiteRtModel,
        metadata_key: *const ::std::os::raw::c_char,
        metadata_buffer: *const ::std::os::raw::c_void,
        metadata_buffer_size: usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMainModelSubgraphIndex(
        model: LiteRtModel,
        main_subgraph_index: *mut LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumModelSubgraphs(
        model: LiteRtModel,
        num_subgraphs: *mut LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetModelSubgraph(
        model: LiteRtModel,
        subgraph_index: LiteRtParamIndex,
        subgraph: *mut LiteRtSubgraph,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumModelSignatures(
        model: LiteRtModel,
        num_signatures: *mut LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetModelSignature(
        model: LiteRtModel,
        signature_index: LiteRtParamIndex,
        signature: *mut LiteRtSignature,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDestroyModel(model: LiteRtModel);
}
extern "C" {
    pub fn LiteRtPushOp(
        op_list: LiteRtOpList,
        op: LiteRtOp,
        partition_index: LiteRtParamIndex,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtSerializeModelWithSignatures(
        model: LiteRtModel,
        buf: *mut *mut u8,
        size: *mut usize,
        offset: *mut usize,
        destroy_model: bool,
        signatures: *mut *mut ::std::os::raw::c_char,
        num_signatures: LiteRtParamIndex,
        options: LiteRtModelSerializationOptions,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtSerializeModel(
        model: LiteRtModel,
        buf: *mut *mut u8,
        size: *mut usize,
        offset: *mut usize,
        destroy_model: bool,
        options: LiteRtModelSerializationOptions,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetAddFusedActivationOption(
        op: LiteRtOp,
        fused_activation: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildAddOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        fused_activation: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetBatchMatmulAdjXOption(op: LiteRtOp, adj_x: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetBatchMatmulAdjYOption(op: LiteRtOp, adj_y: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetBatchMatmulAsymmetricQuantizeInputOption(
        op: LiteRtOp,
        asymmetric_quantize_input: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildBatchMatmulOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        adj_x: *mut bool,
        adj_y: *mut bool,
        asymmetric_quantize_input: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConcatenationFusedActivationOption(
        op: LiteRtOp,
        fused_activation: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConcatenationAxisOption(op: LiteRtOp, axis: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildConcatenationOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        fused_activation: *mut u32,
        axis: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetDivFusedActivationOption(
        op: LiteRtOp,
        fused_activation: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildDivOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        fused_activation: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetFullyConnectedFusedActivationOption(
        op: LiteRtOp,
        fused_activation: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetFullyConnectedWeightsFormatOption(
        op: LiteRtOp,
        weights_format: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetFullyConnectedKeepNumDimsOption(
        op: LiteRtOp,
        keep_num_dims: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtFullyConnectedGetQuantizedBiasTypeOption(
        op: LiteRtOp,
        quantized_bias_type: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetFullyConnectedAsymmetricQuantizeInputOption(
        op: LiteRtOp,
        asymmetric_quantize_input: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildFullyConnectedOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        fused_activation: *mut u32,
        weights_format: *mut u32,
        keep_num_dims: *mut bool,
        quantized_bias_type: *mut u32,
        asymmetric_quantize_input: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMulFusedActivationOption(
        op: LiteRtOp,
        fused_activation: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildMulOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        fused_activation: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSoftmaxBetaOption(op: LiteRtOp, beta: *mut f32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildSoftmaxOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        beta: *mut f32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetStridedSliceBeginMaskOption(op: LiteRtOp, begin_mask: *mut i32)
        -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetStridedSliceEndMaskOption(op: LiteRtOp, end_mask: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetStridedSliceEllipsisMaskOption(
        op: LiteRtOp,
        ellipsis_mask: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetStridedSliceNewAxisMaskOption(
        op: LiteRtOp,
        new_axis_mask: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetStridedSliceShrinkAxisMaskOption(
        op: LiteRtOp,
        shrink_axis_mask: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetStridedSliceOffsetOption(op: LiteRtOp, offset: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildStridedSliceOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        begin_mask: *mut i32,
        end_mask: *mut i32,
        ellipsis_mask: *mut i32,
        new_axis_mask: *mut i32,
        shrink_axis_mask: *mut i32,
        offset: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSubFusedActivationOption(
        op: LiteRtOp,
        fused_activation: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildSubOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        fused_activation: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetReshapeNewShapeOption(
        op: LiteRtOp,
        new_shape: *mut *const i32,
        new_shape_size: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildReshapeOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        new_shape: *mut i32,
        new_shape_size: i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSumKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildSumOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        keepdims: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetReduceMaxKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildReduceMaxOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        keepdims: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetReduceMinKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildReduceMinOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        keepdims: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetReduceAnyKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildReduceAnyOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        keepdims: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetReduceAllKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildReduceAllOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        keepdims: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetPackAxisOption(op: LiteRtOp, axis: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetPackValuesCountOption(op: LiteRtOp, values_count: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildPackOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        axis: *mut i32,
        values_count: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetUnpackAxisOption(op: LiteRtOp, axis: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetUnpackNumOption(op: LiteRtOp, num: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildUnpackOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        axis: *mut i32,
        num: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetGatherAxisOption(op: LiteRtOp, axis: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetGatherBatchDimsOption(op: LiteRtOp, batch_dims: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildGatherOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        axis: *mut i32,
        batch_dims: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMeanKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildMeanOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        keepdims: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSplitNumSplitsOption(op: LiteRtOp, num_splits: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildSplitOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        num_splits: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSHLOCompositeOpName(
        op: LiteRtOp,
        name: *mut *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSHLOCompositeOpDecompositionSubgraphIndex(
        op: LiteRtOp,
        decomposition_subgraph_index: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSHLOCompositeOpAttributes(
        op: LiteRtOp,
        attributes: *mut *const u8,
        attributes_size: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSHLOCompositeOpVersion(op: LiteRtOp, version: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv2dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv2dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv2dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv2dFusedActivationOption(
        op: LiteRtOp,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv2dDilationWOption(
        op: LiteRtOp,
        dilation_w_factor: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv2dDilationHOption(
        op: LiteRtOp,
        dilation_h_factor: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildConv2dOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        padding: *mut u32,
        stride_w: *mut i32,
        stride_h: *mut i32,
        dilation_w_factor: *mut i32,
        dilation_h_factor: *mut i32,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv3dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv3dStrideDOption(op: LiteRtOp, stride_d: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv3dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv3dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv3dFusedActivationOption(
        op: LiteRtOp,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv3dDilationDOption(
        op: LiteRtOp,
        dilation_d_factor: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv3dDilationWOption(
        op: LiteRtOp,
        dilation_w_factor: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetConv3dDilationHOption(
        op: LiteRtOp,
        dilation_h_factor: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildConv3dOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        padding: *mut u32,
        stride_w: *mut i32,
        stride_h: *mut i32,
        stride_d: *mut i32,
        dilation_w_factor: *mut i32,
        dilation_h_factor: *mut i32,
        dilation_d_factor: *mut i32,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetDepthwiseConv2dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetDepthwiseConv2dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetDepthwiseConv2dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetDepthwiseConv2dDepthMultiplierOption(
        op: LiteRtOp,
        depth_multiplier: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetDepthwiseConv2dFusedActivationOption(
        op: LiteRtOp,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetDepthwiseConv2dDilationWOption(
        op: LiteRtOp,
        dilation_w_factor: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetDepthwiseConv2dDilationHOption(
        op: LiteRtOp,
        dilation_h_factor: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildDepthwiseConv2dOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        padding: *mut u32,
        stride_w: *mut i32,
        stride_h: *mut i32,
        depth_multiplier: *mut i32,
        fused_activation_function: *mut u32,
        dilation_w_factor: *mut i32,
        dilation_h_factor: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTransposeConvPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTransposeConvStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTransposeConvStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTransposeConvFusedActivationOption(
        op: LiteRtOp,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildTransposeConvOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        padding: *mut u32,
        stride_w: *mut i32,
        stride_h: *mut i32,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetAveragePool2dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetAveragePool2dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetAveragePool2dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetAveragePool2dFilterWidthOption(
        op: LiteRtOp,
        filter_width: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetAveragePool2dFilterHeightOption(
        op: LiteRtOp,
        filter_height: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetAveragePool2dFusedActivationOption(
        op: LiteRtOp,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildAveragePool2dOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        padding: *mut u32,
        stride_w: *mut i32,
        stride_h: *mut i32,
        filter_width: *mut i32,
        filter_height: *mut i32,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMaxPool2dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMaxPool2dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMaxPool2dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMaxPool2dFilterWidthOption(
        op: LiteRtOp,
        filter_width: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMaxPool2dFilterHeightOption(
        op: LiteRtOp,
        filter_height: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMaxPool2dFusedActivationOption(
        op: LiteRtOp,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildMaxPool2dOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        padding: *mut u32,
        stride_w: *mut i32,
        stride_h: *mut i32,
        filter_width: *mut i32,
        filter_height: *mut i32,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetL2Pool2dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetL2Pool2dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetL2Pool2dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetL2Pool2dFilterWidthOption(op: LiteRtOp, filter_width: *mut i32)
        -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetL2Pool2dFilterHeightOption(
        op: LiteRtOp,
        filter_height: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetL2Pool2dFusedActivationOption(
        op: LiteRtOp,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildL2Pool2dOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        padding: *mut u32,
        stride_w: *mut i32,
        stride_h: *mut i32,
        filter_width: *mut i32,
        filter_height: *mut i32,
        fused_activation_function: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetResizeBilinearAlignCornersOption(
        op: LiteRtOp,
        align_corners: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetResizeBilinearHalfPixelCenterOption(
        op: LiteRtOp,
        half_pixel_centers: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildResizeBilinearOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        align_corners: *mut bool,
        half_pixel_centers: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetLeakyReluAlphaOption(op: LiteRtOp, alpha: *mut f32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildLeakyReluOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        alpha: *mut f32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetDepthToSpaceBlockSizeOption(op: LiteRtOp, block_size: *mut i32)
        -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildDepthToSpaceOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        block_size: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSpaceToDepthBlockSizeOption(op: LiteRtOp, block_size: *mut i32)
        -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildSpaceToDepthOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        block_size: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetResizeNearestNeighborAlignCornersOption(
        op: LiteRtOp,
        align_corners: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetResizeNearestNeighborHalfPixelCenterOption(
        op: LiteRtOp,
        half_pixel_centers: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildResizeNearestNeighborOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        align_corners: *mut bool,
        half_pixel_centers: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetCumsumExclusiveOption(op: LiteRtOp, exclusive: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetCumsumReverseOption(op: LiteRtOp, reverse: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildCumsumOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        exclusive: *mut bool,
        reverse: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetGeluApproximateOption(op: LiteRtOp, approximate: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildGeluOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        approximate: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMirrorPadModeOption(op: LiteRtOp, mode: *mut u32) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildMirrorPadOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        mode: *mut u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSqueezeDimsOption(
        op: LiteRtOp,
        squeeze_dims: *mut *const i32,
        num_squeeze_dims: *mut i32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtBuilderBuildSqueezeOpOption(
        builder: LiteRtBuilder,
        op: LiteRtOp,
        squeeze_dims: *const i32,
        num_squeeze_dims: i32,
    ) -> LiteRtStatus;
}
pub type LiteRtGLenum = u32;
pub type LiteRtGLuint = u32;
pub type LiteRtGLint = i32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtEglContextStruct {
    _unused: [u8; 0],
}
pub type LiteRtEglContext = *mut LiteRtEglContextStruct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtEglDisplayStruct {
    _unused: [u8; 0],
}
pub type LiteRtEglDisplay = *mut LiteRtEglDisplayStruct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtEglSyncKhrStruct {
    _unused: [u8; 0],
}
pub type LiteRtEglSyncKhr = *mut LiteRtEglSyncKhrStruct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _cl_mem {
    _unused: [u8; 0],
}
#[doc = " Define LiteRT aliases for OpenCL types without requiring downstream users to\n include the OpenCL SDK headers just to compile LiteRT public headers.\n\n The OpenCL C API models both `cl_mem` and `cl_event` as opaque pointers to\n implementation-defined structs. Forward-declaring the same struct tags keeps\n LiteRT's public ABI compatible with code that later includes `CL/cl.h`,\n while avoiding a transitive dependency on the OpenCL headers for consumers\n that never bind directly to raw OpenCL objects."]
pub type LiteRtClMem = *mut _cl_mem;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _cl_event {
    _unused: [u8; 0],
}
pub type LiteRtClEvent = *mut _cl_event;
pub type LiteRtClInt = i32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUBufferImpl {
    _unused: [u8; 0],
}
pub type LiteRtWGPUBufferImpl = WGPUBufferImpl;
pub type LiteRtWGPUBuffer = *mut LiteRtWGPUBufferImpl;
extern "C" {
    pub fn LiteRtCreateTensorBufferRequirements(
        num_supported_tensor_buffer_types: ::std::os::raw::c_int,
        supported_tensor_buffer_types: *const LiteRtTensorBufferType,
        buffer_size: usize,
        num_strides: ::std::os::raw::c_int,
        strides: *const u32,
        requirements: *mut LiteRtTensorBufferRequirements,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferRequirementsWithAlignment(
        num_supported_tensor_buffer_types: ::std::os::raw::c_int,
        supported_tensor_buffer_types: *const LiteRtTensorBufferType,
        buffer_size: usize,
        num_strides: ::std::os::raw::c_int,
        strides: *const u32,
        alignment: usize,
        requirements: *mut LiteRtTensorBufferRequirements,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumTensorBufferRequirementsSupportedBufferTypes(
        requirements: LiteRtTensorBufferRequirements,
        num_types: *mut ::std::os::raw::c_int,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferRequirementsSupportedTensorBufferType(
        requirements: LiteRtTensorBufferRequirements,
        type_index: ::std::os::raw::c_int,
        type_: *mut LiteRtTensorBufferType,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferRequirementsBufferSize(
        requirements: LiteRtTensorBufferRequirements,
        buffer_size: *mut usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferRequirementsStrides(
        requirements: LiteRtTensorBufferRequirements,
        num_strides: *mut ::std::os::raw::c_int,
        strides: *mut *const u32,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferRequirementsAlignment(
        requirements: LiteRtTensorBufferRequirements,
        alignment: *mut usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtJoinTensorBufferRequirements(
        src_requirements_1: LiteRtTensorBufferRequirements,
        src_requirements_2: LiteRtTensorBufferRequirements,
        joined_requirements: *mut LiteRtTensorBufferRequirements,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDestroyTensorBufferRequirements(requirements: LiteRtTensorBufferRequirements);
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromHostMemory(
        tensor_type: *const LiteRtRankedTensorType,
        host_buffer_addr: *mut ::std::os::raw::c_void,
        host_buffer_size: usize,
        deallocator: LiteRtHostMemoryDeallocator,
        buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferHostMemory(
        tensor_buffer: LiteRtTensorBuffer,
        host_memory_addr: *mut *mut ::std::os::raw::c_void,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromAhwb(
        env: LiteRtEnvironment,
        tensor_type: *const LiteRtRankedTensorType,
        ahwb: *mut AHardwareBuffer,
        ahwb_offset: usize,
        deallocator: LiteRtAhwbDeallocator,
        buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferAhwb(
        tensor_buffer: LiteRtTensorBuffer,
        ahwb: *mut *mut AHardwareBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromIonBuffer(
        tensor_type: *const LiteRtRankedTensorType,
        ion_buffer_addr: *mut ::std::os::raw::c_void,
        ion_buffer_fd: ::std::os::raw::c_int,
        ion_buffer_size: usize,
        ion_buffer_offset: usize,
        deallocator: LiteRtIonDeallocator,
        buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferIonBuffer(
        buffer: LiteRtTensorBuffer,
        ion_buffer_addr: *mut *mut ::std::os::raw::c_void,
        ion_buffer_fd: *mut ::std::os::raw::c_int,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromDmaBufBuffer(
        tensor_type: *const LiteRtRankedTensorType,
        dmabuf_buffer_addr: *mut ::std::os::raw::c_void,
        dmabuf_buffer_fd: ::std::os::raw::c_int,
        dmabuf_buffer_size: usize,
        dmabuf_buffer_offset: usize,
        deallocator: LiteRtDmaBufDeallocator,
        buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferDmaBufBuffer(
        tensor_buffer: LiteRtTensorBuffer,
        dmabuf_buffer_addr: *mut *mut ::std::os::raw::c_void,
        dmabuf_buffer_fd: *mut ::std::os::raw::c_int,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromFastRpcBuffer(
        tensor_type: *const LiteRtRankedTensorType,
        fastrpc_buffer_addr: *mut ::std::os::raw::c_void,
        fastrpc_buffer_fd: ::std::os::raw::c_int,
        fastrpc_buffer_size: usize,
        fastrpc_buffer_offset: usize,
        deallocator: LiteRtFastRpcDeallocator,
        tensor_buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferFastRpcBuffer(
        tensor_buffer: LiteRtTensorBuffer,
        fastrpc_buffer_addr: *mut *mut ::std::os::raw::c_void,
        fastrpc_buffer_fd: *mut ::std::os::raw::c_int,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromOpenClMemory(
        env: LiteRtEnvironment,
        tensor_type: *const LiteRtRankedTensorType,
        buffer_type: LiteRtTensorBufferType,
        cl_mem_addr: LiteRtClMem,
        opencl_buffer_size: usize,
        deallocator: LiteRtOpenClDeallocator,
        buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferOpenClMemory(
        tensor_buffer: LiteRtTensorBuffer,
        cl_mem_addr: *mut LiteRtClMem,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferCustomTensorBufferHandle(
        tensor_buffer: LiteRtTensorBuffer,
        hw_memory_handle: *mut HwMemoryHandle,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromGlBuffer(
        env: LiteRtEnvironment,
        tensor_type: *const LiteRtRankedTensorType,
        target: LiteRtGLenum,
        id: LiteRtGLuint,
        size_bytes: usize,
        offset: usize,
        deallocator: LiteRtGlBufferDeallocator,
        buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferGlBuffer(
        tensor_buffer: LiteRtTensorBuffer,
        target: *mut LiteRtGLenum,
        id: *mut LiteRtGLuint,
        size_bytes: *mut usize,
        offset: *mut usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromGlTexture(
        env: LiteRtEnvironment,
        tensor_type: *const LiteRtRankedTensorType,
        target: LiteRtGLenum,
        id: LiteRtGLuint,
        format: LiteRtGLenum,
        size_bytes: usize,
        layer: LiteRtGLint,
        deallocator: LiteRtGlTextureDeallocator,
        buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferGlTexture(
        tensor_buffer: LiteRtTensorBuffer,
        target: *mut LiteRtGLenum,
        id: *mut LiteRtGLuint,
        format: *mut LiteRtGLenum,
        size_bytes: *mut usize,
        layer: *mut LiteRtGLint,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromWebGpuBuffer(
        env: LiteRtEnvironment,
        tensor_type: *const LiteRtRankedTensorType,
        buffer_type: LiteRtTensorBufferType,
        wgpu_buffer: LiteRtWGPUBuffer,
        wgpu_buffer_size: usize,
        deallocator: LiteRtWebGpuBufferDeallocator,
        tensor_buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromWebGpuTexture(
        env: LiteRtEnvironment,
        tensor_type: *const LiteRtRankedTensorType,
        webgpu_texture: *mut ::std::os::raw::c_void,
        webgpu_texture_size: usize,
        deallocator: LiteRtWebGpuTextureDeallocator,
        tensor_buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferWebGpuBuffer(
        tensor_buffer: LiteRtTensorBuffer,
        hw_memory_handle: *mut HwMemoryHandle,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateTensorBufferFromMetalMemory(
        env: LiteRtEnvironment,
        tensor_type: *const LiteRtRankedTensorType,
        buffer_type: LiteRtTensorBufferType,
        metal_buffer: *mut ::std::os::raw::c_void,
        metal_buffer_size: usize,
        deallocator: LiteRtMetalDeallocator,
        tensor_buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferMetalMemory(
        tensor_buffer: LiteRtTensorBuffer,
        hw_memory_handle: *mut HwMemoryHandle,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferVulkanMemory(
        tensor_buffer: LiteRtTensorBuffer,
        hw_memory_handle: *mut HwMemoryHandle,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateManagedTensorBuffer(
        env: LiteRtEnvironment,
        buffer_type: LiteRtTensorBufferType,
        tensor_type: *const LiteRtRankedTensorType,
        buffer_size: usize,
        buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateManagedTensorBufferFromRequirements(
        env: LiteRtEnvironment,
        tensor_type: *const LiteRtRankedTensorType,
        requirements: LiteRtTensorBufferRequirements,
        buffer: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDuplicateTensorBuffer(tensor_buffer: LiteRtTensorBuffer) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferType(
        tensor_buffer: LiteRtTensorBuffer,
        buffer_type: *mut LiteRtTensorBufferType,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferTensorType(
        tensor_buffer: LiteRtTensorBuffer,
        tensor_type: *mut LiteRtRankedTensorType,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferSize(
        tensor_buffer: LiteRtTensorBuffer,
        size: *mut usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferPackedSize(
        tensor_buffer: LiteRtTensorBuffer,
        size: *mut usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferOffset(
        tensor_buffer: LiteRtTensorBuffer,
        offset: *mut usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtHasTensorBufferEvent(
        tensor_buffer: LiteRtTensorBuffer,
        has_event: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetTensorBufferEvent(
        tensor_buffer: LiteRtTensorBuffer,
        event: *mut LiteRtEvent,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtSetTensorBufferEvent(
        tensor_buffer: LiteRtTensorBuffer,
        event: LiteRtEvent,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtClearTensorBufferEvent(tensor_buffer: LiteRtTensorBuffer) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtLockTensorBuffer(
        tensor_buffer: LiteRtTensorBuffer,
        host_mem_addr: *mut *mut ::std::os::raw::c_void,
        lock_mode: LiteRtTensorBufferLockMode,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtUnlockTensorBuffer(buffer: LiteRtTensorBuffer) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtClearTensorBuffer(buffer: LiteRtTensorBuffer) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDestroyTensorBuffer(buffer: LiteRtTensorBuffer);
}
pub const LiteRtEventTypeUnknown: LiteRtEventType = 0;
pub const LiteRtEventTypeSyncFenceFd: LiteRtEventType = 1;
pub const LiteRtEventTypeOpenCl: LiteRtEventType = 2;
pub const LiteRtEventTypeEglSyncFence: LiteRtEventType = 3;
pub const LiteRtEventTypeEglNativeSyncFence: LiteRtEventType = 4;
pub const LiteRtEventTypeCustom: LiteRtEventType = 5;
pub type LiteRtEventType = ::std::os::raw::c_uint;
pub type LiteRtCustomEvent = *mut LiteRtCustomEventT;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct LiteRtCustomEventT {
    pub Retain: ::std::option::Option<unsafe extern "C" fn(event: LiteRtCustomEvent)>,
    pub Release: ::std::option::Option<unsafe extern "C" fn(event: LiteRtCustomEvent)>,
    pub Wait:
        ::std::option::Option<unsafe extern "C" fn(event: LiteRtCustomEvent, timeout_in_ms: i64)>,
    pub IsSignaled: ::std::option::Option<
        unsafe extern "C" fn(event: LiteRtCustomEvent) -> ::std::os::raw::c_int,
    >,
    pub GetNative: ::std::option::Option<
        unsafe extern "C" fn(event: LiteRtCustomEvent) -> *mut ::std::os::raw::c_void,
    >,
}
extern "C" {
    pub fn LiteRtCreateEventFromSyncFenceFd(
        env: LiteRtEnvironment,
        sync_fence_fd: ::std::os::raw::c_int,
        owns_fd: bool,
        event: *mut LiteRtEvent,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateEventFromOpenClEvent(
        env: LiteRtEnvironment,
        cl_event: LiteRtClEvent,
        event: *mut LiteRtEvent,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateEventFromEglSyncFence(
        env: LiteRtEnvironment,
        egl_sync: LiteRtEglSyncKhr,
        event: *mut LiteRtEvent,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCreateManagedEvent(
        env: LiteRtEnvironment,
        type_: LiteRtEventType,
        event: *mut LiteRtEvent,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtSetCustomEvent(
        event: LiteRtEvent,
        custom_event: LiteRtCustomEvent,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetCustomEvent(
        event: LiteRtEvent,
        custom_event: *mut LiteRtCustomEvent,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetEventCustomNativeEvent(
        event: LiteRtEvent,
        native: *mut *mut ::std::os::raw::c_void,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetEventEventType(event: LiteRtEvent, type_: *mut LiteRtEventType)
        -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetEventSyncFenceFd(
        event: LiteRtEvent,
        sync_fence_fd: *mut ::std::os::raw::c_int,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetEventOpenClEvent(
        event: LiteRtEvent,
        cl_event: *mut LiteRtClEvent,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetEventEglSync(
        event: LiteRtEvent,
        egl_sync: *mut LiteRtEglSyncKhr,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtWaitEvent(event: LiteRtEvent, timeout_in_ms: i64) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtSignalEvent(event: LiteRtEvent) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtIsEventSignaled(event: LiteRtEvent, is_signaled: *mut bool) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDupFdEvent(event: LiteRtEvent, dup_fd: *mut ::std::os::raw::c_int)
        -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDestroyEvent(event: LiteRtEvent);
}
pub const kLiteRtSchedulingInfoFieldOriginalUid: LiteRtSchedulingInfoField = 1;
pub const kLiteRtSchedulingInfoFieldDebugFeatureId: LiteRtSchedulingInfoField = 2;
pub const kLiteRtSchedulingInfoFieldJobPriority: LiteRtSchedulingInfoField = 4;
pub const kLiteRtSchedulingInfoFieldGroupId: LiteRtSchedulingInfoField = 8;
pub type LiteRtSchedulingInfoField = ::std::os::raw::c_uint;
pub const kLiteRtSchedulingInfoGroupIdSize: _bindgen_ty_1 = 16;
pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
pub const kLiteRtSchedulingInfoJobPriorityHighest: LiteRtSchedulingJobPriority = 0;
pub const kLiteRtSchedulingInfoJobPriorityLowest: LiteRtSchedulingJobPriority = 1000;
pub type LiteRtSchedulingJobPriority = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LiteRtSchedulingInfo {
    pub fields_mask: u32,
    pub original_uid: i32,
    pub debug_feature_id: *const ::std::os::raw::c_char,
    pub job_priority: i32,
    pub group_id: [u8; 16usize],
}
impl Default for LiteRtSchedulingInfo {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
extern "C" {
    pub fn LiteRtCreateCompiledModel(
        environment: LiteRtEnvironment,
        model: LiteRtModel,
        compilation_options: LiteRtOptions,
        compiled_model: *mut LiteRtCompiledModel,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetCompiledModelInputBufferRequirements(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        input_index: LiteRtParamIndex,
        buffer_requirements: *mut LiteRtTensorBufferRequirements,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetCompiledModelOutputBufferRequirements(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        output_index: LiteRtParamIndex,
        buffer_requirements: *mut LiteRtTensorBufferRequirements,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetCompiledModelInputTensorLayout(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        input_index: LiteRtParamIndex,
        layout: *mut LiteRtLayout,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetCompiledModelOutputTensorLayouts(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        num_layouts: usize,
        layouts: *mut LiteRtLayout,
        update_allocation: bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetCompiledModelEnvironment(
        compiled_model: LiteRtCompiledModel,
        environment: *mut LiteRtEnvironment,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtRunCompiledModel(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        num_input_buffers: usize,
        input_buffers: *mut LiteRtTensorBuffer,
        num_output_buffers: usize,
        output_buffers: *mut LiteRtTensorBuffer,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtRunCompiledModelWithOptions(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        num_input_buffers: usize,
        input_buffers: *mut LiteRtTensorBuffer,
        num_output_buffers: usize,
        output_buffers: *mut LiteRtTensorBuffer,
        options: LiteRtOptions,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtRunCompiledModelAsync(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        num_input_buffers: usize,
        input_buffers: *mut LiteRtTensorBuffer,
        num_output_buffers: usize,
        output_buffers: *mut LiteRtTensorBuffer,
        async_: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtRunCompiledModelAsyncWithOptions(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        num_input_buffers: usize,
        input_buffers: *mut LiteRtTensorBuffer,
        num_output_buffers: usize,
        output_buffers: *mut LiteRtTensorBuffer,
        async_: *mut bool,
        options: LiteRtOptions,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelSetSchedulingInfo(
        compiled_model: LiteRtCompiledModel,
        scheduling_info: *const LiteRtSchedulingInfo,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtRunCompiledModelWithSchedulingInfo(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        num_input_buffers: usize,
        input_buffers: *mut LiteRtTensorBuffer,
        num_output_buffers: usize,
        output_buffers: *mut LiteRtTensorBuffer,
        scheduling_info: *const LiteRtSchedulingInfo,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtRunCompiledModelAsyncWithSchedulingInfo(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        num_input_buffers: usize,
        input_buffers: *mut LiteRtTensorBuffer,
        num_output_buffers: usize,
        output_buffers: *mut LiteRtTensorBuffer,
        async_: *mut bool,
        scheduling_info: *const LiteRtSchedulingInfo,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtSetCompiledModelCancellationFunction(
        compiled_model: LiteRtCompiledModel,
        data: *mut ::std::os::raw::c_void,
        check_cancelled_func: ::std::option::Option<
            unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> bool,
        >,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDestroyCompiledModel(compiled_model: LiteRtCompiledModel);
}
extern "C" {
    pub fn LiteRtCompiledModelStartMetricsCollection(
        compiled_model: LiteRtCompiledModel,
        detail_level: ::std::os::raw::c_int,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelStopMetricsCollection(
        compiled_model: LiteRtCompiledModel,
        metrics: LiteRtMetrics,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelIsFullyAccelerated(
        compiled_model: LiteRtCompiledModel,
        fully_accelerated: *mut bool,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelGetProfiler(
        compiled_model: LiteRtCompiledModel,
        profiler: *mut LiteRtProfiler,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelResizeInputTensor(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        input_index: LiteRtParamIndex,
        dims: *const ::std::os::raw::c_int,
        dims_size: usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelResizeInputTensorNonStrict(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        input_index: LiteRtParamIndex,
        dims: *const ::std::os::raw::c_int,
        dims_size: usize,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelSetDispatchAnnotation(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        key: *const ::std::os::raw::c_char,
        value: *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelGetDispatchAnnotation(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        key: *const ::std::os::raw::c_char,
        value: *mut *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelRemoveDispatchAnnotation(
        compiled_model: LiteRtCompiledModel,
        signature_index: LiteRtParamIndex,
        key: *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelReportError(
        compiled_model: LiteRtCompiledModel,
        format: *const ::std::os::raw::c_char,
        ...
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelClearErrors(compiled_model: LiteRtCompiledModel) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtCompiledModelGetErrorMessages(
        compiled_model: LiteRtCompiledModel,
        error_messages: *mut *mut ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
pub const kLiteRtCompilerOptionsPartitionStrategyDefault: LiteRtCompilerOptionsPartitionStrategy =
    0;
pub const kLiteRtCompilerOptionsPartitionStrategyWeaklyConnected:
    LiteRtCompilerOptionsPartitionStrategy = 1;
pub type LiteRtCompilerOptionsPartitionStrategy = ::std::os::raw::c_uint;
pub const kLiteRtCpuKernelModeXnnpack: LiteRtCpuKernelMode = 0;
pub const kLiteRtCpuKernelModeReference: LiteRtCpuKernelMode = 1;
pub const kLiteRtCpuKernelModeBuiltin: LiteRtCpuKernelMode = 2;
pub type LiteRtCpuKernelMode = ::std::os::raw::c_uint;
pub const DEFAULT: LiteRtProfilerEventType = 1;
pub const OPERATOR_INVOKE_EVENT: LiteRtProfilerEventType = 2;
pub const DELEGATE_OPERATOR_INVOKE_EVENT: LiteRtProfilerEventType = 4;
pub const DELEGATE_PROFILED_OPERATOR_INVOKE_EVENT: LiteRtProfilerEventType = 8;
pub const GENERAL_RUNTIME_INSTRUMENTATION_EVENT: LiteRtProfilerEventType = 16;
pub const TELEMETRY_EVENT: LiteRtProfilerEventType = 32;
pub const TELEMETRY_REPORT_SETTINGS: LiteRtProfilerEventType = 64;
pub const TELEMETRY_DELEGATE_EVENT: LiteRtProfilerEventType = 128;
pub const TELEMETRY_DELEGATE_REPORT_SETTINGS: LiteRtProfilerEventType = 256;
pub type LiteRtProfilerEventType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct LiteRtMemoryUsage {
    pub total_allocated_bytes: usize,
    pub in_use_allocated_bytes: usize,
    pub private_footprint_bytes: usize,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct LiteRtMetric {
    pub name: *const ::std::os::raw::c_char,
    pub value: LiteRtAny,
}
impl Default for LiteRtMetric {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
extern "C" {
    pub fn LiteRtCreateMetrics(metrics: *mut LiteRtMetrics) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetNumMetrics(
        metrics: LiteRtMetrics,
        num_metrics: *mut ::std::os::raw::c_int,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMetric(
        metrics: LiteRtMetrics,
        metric_index: ::std::os::raw::c_int,
        metric: *mut LiteRtMetric,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDestroyMetrics(metrics: LiteRtMetrics);
}
pub const kLiteRtLogSeverityDebug: LiteRtLogSeverity = -1;
pub const kLiteRtLogSeverityVerbose: LiteRtLogSeverity = 0;
pub const kLiteRtLogSeverityInfo: LiteRtLogSeverity = 1;
pub const kLiteRtLogSeverityWarning: LiteRtLogSeverity = 2;
pub const kLiteRtLogSeverityError: LiteRtLogSeverity = 3;
pub const kLiteRtLogSeveritySilent: LiteRtLogSeverity = 4;
pub type LiteRtLogSeverity = i8;
extern "C" {
    pub fn LiteRtGetLogSeverityName(severity: LiteRtLogSeverity) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn LiteRtCreateLogger(logger: *mut LiteRtLogger) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetMinLoggerSeverity(
        logger: LiteRtLogger,
        min_severity: *mut LiteRtLogSeverity,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtSetMinLoggerSeverity(
        logger: LiteRtLogger,
        min_severity: LiteRtLogSeverity,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtLoggerLog(
        logger: LiteRtLogger,
        severity: LiteRtLogSeverity,
        format: *const ::std::os::raw::c_char,
        ...
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetLoggerIdentifier(
        logger: LiteRtLoggerConst,
        identifier: *mut *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDestroyLogger(logger: LiteRtLogger);
}
extern "C" {
    pub fn LiteRtCreateSinkLogger(logger: *mut LiteRtLogger) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSinkLoggerSize(logger: LiteRtLogger, size: *mut usize) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetSinkLoggerMessage(
        logger: LiteRtLogger,
        idx: usize,
        message: *mut *const ::std::os::raw::c_char,
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtClearSinkLogger(logger: LiteRtLogger) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtGetDefaultLogger() -> LiteRtLogger;
}
extern "C" {
    pub fn LiteRtSetDefaultLogger(logger: LiteRtLogger) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtDefaultLoggerLog(
        severity: LiteRtLogSeverity,
        format: *const ::std::os::raw::c_char,
        ...
    ) -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtUseStandardLogger() -> LiteRtStatus;
}
extern "C" {
    pub fn LiteRtUseSinkLogger() -> LiteRtStatus;
}
