oracle 0.5.7

/* automatically generated by rust-bindgen 0.60.1 */

pub const DPI_MAJOR_VERSION: u32 = 4;
pub const DPI_MINOR_VERSION: u32 = 6;
pub const DPI_PATCH_LEVEL: u32 = 0;
pub const DPI_DEFAULT_FETCH_ARRAY_SIZE: u32 = 100;
pub const DPI_DEFAULT_PREFETCH_ROWS: u32 = 2;
pub const DPI_DEFAULT_PING_INTERVAL: u32 = 60;
pub const DPI_DEFAULT_PING_TIMEOUT: u32 = 5000;
pub const DPI_DEFAULT_STMT_CACHE_SIZE: u32 = 20;
pub const DPI_DEQ_WAIT_NO_WAIT: u32 = 0;
pub const DPI_MAX_INT64_PRECISION: u32 = 18;
pub const DPI_SUCCESS: u32 = 0;
pub const DPI_FAILURE: i32 = -1;
pub const DPI_DEBUG_LEVEL_UNREPORTED_ERRORS: u32 = 1;
pub const DPI_DEBUG_LEVEL_REFS: u32 = 2;
pub const DPI_DEBUG_LEVEL_FNS: u32 = 4;
pub const DPI_DEBUG_LEVEL_ERRORS: u32 = 8;
pub const DPI_DEBUG_LEVEL_SQL: u32 = 16;
pub const DPI_DEBUG_LEVEL_MEM: u32 = 32;
pub const DPI_DEBUG_LEVEL_LOAD_LIB: u32 = 64;
pub const DPI_MODE_AUTH_DEFAULT: u32 = 0;
pub const DPI_MODE_AUTH_SYSDBA: u32 = 2;
pub const DPI_MODE_AUTH_SYSOPER: u32 = 4;
pub const DPI_MODE_AUTH_PRELIM: u32 = 8;
pub const DPI_MODE_AUTH_SYSASM: u32 = 32768;
pub const DPI_MODE_AUTH_SYSBKP: u32 = 131072;
pub const DPI_MODE_AUTH_SYSDGD: u32 = 262144;
pub const DPI_MODE_AUTH_SYSKMT: u32 = 524288;
pub const DPI_MODE_AUTH_SYSRAC: u32 = 1048576;
pub const DPI_MODE_CONN_CLOSE_DEFAULT: u32 = 0;
pub const DPI_MODE_CONN_CLOSE_DROP: u32 = 1;
pub const DPI_MODE_CONN_CLOSE_RETAG: u32 = 2;
pub const DPI_MODE_CREATE_DEFAULT: u32 = 0;
pub const DPI_MODE_CREATE_THREADED: u32 = 1;
pub const DPI_MODE_CREATE_EVENTS: u32 = 4;
pub const DPI_MODE_DEQ_BROWSE: u32 = 1;
pub const DPI_MODE_DEQ_LOCKED: u32 = 2;
pub const DPI_MODE_DEQ_REMOVE: u32 = 3;
pub const DPI_MODE_DEQ_REMOVE_NO_DATA: u32 = 4;
pub const DPI_DEQ_NAV_FIRST_MSG: u32 = 1;
pub const DPI_DEQ_NAV_NEXT_TRANSACTION: u32 = 2;
pub const DPI_DEQ_NAV_NEXT_MSG: u32 = 3;
pub const DPI_EVENT_NONE: u32 = 0;
pub const DPI_EVENT_STARTUP: u32 = 1;
pub const DPI_EVENT_SHUTDOWN: u32 = 2;
pub const DPI_EVENT_SHUTDOWN_ANY: u32 = 3;
pub const DPI_EVENT_DEREG: u32 = 5;
pub const DPI_EVENT_OBJCHANGE: u32 = 6;
pub const DPI_EVENT_QUERYCHANGE: u32 = 7;
pub const DPI_EVENT_AQ: u32 = 100;
pub const DPI_JSON_OPT_DEFAULT: u32 = 0;
pub const DPI_JSON_OPT_NUMBER_AS_STRING: u32 = 1;
pub const DPI_JSON_OPT_DATE_AS_DOUBLE: u32 = 2;
pub const DPI_MODE_EXEC_DEFAULT: u32 = 0;
pub const DPI_MODE_EXEC_DESCRIBE_ONLY: u32 = 16;
pub const DPI_MODE_EXEC_COMMIT_ON_SUCCESS: u32 = 32;
pub const DPI_MODE_EXEC_BATCH_ERRORS: u32 = 128;
pub const DPI_MODE_EXEC_PARSE_ONLY: u32 = 256;
pub const DPI_MODE_EXEC_ARRAY_DML_ROWCOUNTS: u32 = 1048576;
pub const DPI_MODE_FETCH_NEXT: u32 = 2;
pub const DPI_MODE_FETCH_FIRST: u32 = 4;
pub const DPI_MODE_FETCH_LAST: u32 = 8;
pub const DPI_MODE_FETCH_PRIOR: u32 = 16;
pub const DPI_MODE_FETCH_ABSOLUTE: u32 = 32;
pub const DPI_MODE_FETCH_RELATIVE: u32 = 64;
pub const DPI_MODE_MSG_PERSISTENT: u32 = 1;
pub const DPI_MODE_MSG_BUFFERED: u32 = 2;
pub const DPI_MODE_MSG_PERSISTENT_OR_BUFFERED: u32 = 3;
pub const DPI_MSG_STATE_READY: u32 = 0;
pub const DPI_MSG_STATE_WAITING: u32 = 1;
pub const DPI_MSG_STATE_PROCESSED: u32 = 2;
pub const DPI_MSG_STATE_EXPIRED: u32 = 3;
pub const DPI_NATIVE_TYPE_INT64: u32 = 3000;
pub const DPI_NATIVE_TYPE_UINT64: u32 = 3001;
pub const DPI_NATIVE_TYPE_FLOAT: u32 = 3002;
pub const DPI_NATIVE_TYPE_DOUBLE: u32 = 3003;
pub const DPI_NATIVE_TYPE_BYTES: u32 = 3004;
pub const DPI_NATIVE_TYPE_TIMESTAMP: u32 = 3005;
pub const DPI_NATIVE_TYPE_INTERVAL_DS: u32 = 3006;
pub const DPI_NATIVE_TYPE_INTERVAL_YM: u32 = 3007;
pub const DPI_NATIVE_TYPE_LOB: u32 = 3008;
pub const DPI_NATIVE_TYPE_OBJECT: u32 = 3009;
pub const DPI_NATIVE_TYPE_STMT: u32 = 3010;
pub const DPI_NATIVE_TYPE_BOOLEAN: u32 = 3011;
pub const DPI_NATIVE_TYPE_ROWID: u32 = 3012;
pub const DPI_NATIVE_TYPE_JSON: u32 = 3013;
pub const DPI_NATIVE_TYPE_JSON_OBJECT: u32 = 3014;
pub const DPI_NATIVE_TYPE_JSON_ARRAY: u32 = 3015;
pub const DPI_NATIVE_TYPE_NULL: u32 = 3016;
pub const DPI_OPCODE_ALL_OPS: u32 = 0;
pub const DPI_OPCODE_ALL_ROWS: u32 = 1;
pub const DPI_OPCODE_INSERT: u32 = 2;
pub const DPI_OPCODE_UPDATE: u32 = 4;
pub const DPI_OPCODE_DELETE: u32 = 8;
pub const DPI_OPCODE_ALTER: u32 = 16;
pub const DPI_OPCODE_DROP: u32 = 32;
pub const DPI_OPCODE_UNKNOWN: u32 = 64;
pub const DPI_ORACLE_TYPE_NONE: u32 = 2000;
pub const DPI_ORACLE_TYPE_VARCHAR: u32 = 2001;
pub const DPI_ORACLE_TYPE_NVARCHAR: u32 = 2002;
pub const DPI_ORACLE_TYPE_CHAR: u32 = 2003;
pub const DPI_ORACLE_TYPE_NCHAR: u32 = 2004;
pub const DPI_ORACLE_TYPE_ROWID: u32 = 2005;
pub const DPI_ORACLE_TYPE_RAW: u32 = 2006;
pub const DPI_ORACLE_TYPE_NATIVE_FLOAT: u32 = 2007;
pub const DPI_ORACLE_TYPE_NATIVE_DOUBLE: u32 = 2008;
pub const DPI_ORACLE_TYPE_NATIVE_INT: u32 = 2009;
pub const DPI_ORACLE_TYPE_NUMBER: u32 = 2010;
pub const DPI_ORACLE_TYPE_DATE: u32 = 2011;
pub const DPI_ORACLE_TYPE_TIMESTAMP: u32 = 2012;
pub const DPI_ORACLE_TYPE_TIMESTAMP_TZ: u32 = 2013;
pub const DPI_ORACLE_TYPE_TIMESTAMP_LTZ: u32 = 2014;
pub const DPI_ORACLE_TYPE_INTERVAL_DS: u32 = 2015;
pub const DPI_ORACLE_TYPE_INTERVAL_YM: u32 = 2016;
pub const DPI_ORACLE_TYPE_CLOB: u32 = 2017;
pub const DPI_ORACLE_TYPE_NCLOB: u32 = 2018;
pub const DPI_ORACLE_TYPE_BLOB: u32 = 2019;
pub const DPI_ORACLE_TYPE_BFILE: u32 = 2020;
pub const DPI_ORACLE_TYPE_STMT: u32 = 2021;
pub const DPI_ORACLE_TYPE_BOOLEAN: u32 = 2022;
pub const DPI_ORACLE_TYPE_OBJECT: u32 = 2023;
pub const DPI_ORACLE_TYPE_LONG_VARCHAR: u32 = 2024;
pub const DPI_ORACLE_TYPE_LONG_RAW: u32 = 2025;
pub const DPI_ORACLE_TYPE_NATIVE_UINT: u32 = 2026;
pub const DPI_ORACLE_TYPE_JSON: u32 = 2027;
pub const DPI_ORACLE_TYPE_JSON_OBJECT: u32 = 2028;
pub const DPI_ORACLE_TYPE_JSON_ARRAY: u32 = 2029;
pub const DPI_ORACLE_TYPE_UROWID: u32 = 2030;
pub const DPI_ORACLE_TYPE_LONG_NVARCHAR: u32 = 2031;
pub const DPI_ORACLE_TYPE_MAX: u32 = 2032;
pub const DPI_MODE_POOL_CLOSE_DEFAULT: u32 = 0;
pub const DPI_MODE_POOL_CLOSE_FORCE: u32 = 1;
pub const DPI_MODE_POOL_GET_WAIT: u32 = 0;
pub const DPI_MODE_POOL_GET_NOWAIT: u32 = 1;
pub const DPI_MODE_POOL_GET_FORCEGET: u32 = 2;
pub const DPI_MODE_POOL_GET_TIMEDWAIT: u32 = 3;
pub const DPI_PURITY_DEFAULT: u32 = 0;
pub const DPI_PURITY_NEW: u32 = 1;
pub const DPI_PURITY_SELF: u32 = 2;
pub const DPI_MODE_SHUTDOWN_DEFAULT: u32 = 0;
pub const DPI_MODE_SHUTDOWN_TRANSACTIONAL: u32 = 1;
pub const DPI_MODE_SHUTDOWN_TRANSACTIONAL_LOCAL: u32 = 2;
pub const DPI_MODE_SHUTDOWN_IMMEDIATE: u32 = 3;
pub const DPI_MODE_SHUTDOWN_ABORT: u32 = 4;
pub const DPI_MODE_SHUTDOWN_FINAL: u32 = 5;
pub const DPI_SODA_FLAGS_DEFAULT: u32 = 0;
pub const DPI_SODA_FLAGS_ATOMIC_COMMIT: u32 = 1;
pub const DPI_SODA_FLAGS_CREATE_COLL_MAP: u32 = 2;
pub const DPI_SODA_FLAGS_INDEX_DROP_FORCE: u32 = 4;
pub const DPI_MODE_STARTUP_DEFAULT: u32 = 0;
pub const DPI_MODE_STARTUP_FORCE: u32 = 1;
pub const DPI_MODE_STARTUP_RESTRICT: u32 = 2;
pub const DPI_STMT_TYPE_UNKNOWN: u32 = 0;
pub const DPI_STMT_TYPE_SELECT: u32 = 1;
pub const DPI_STMT_TYPE_UPDATE: u32 = 2;
pub const DPI_STMT_TYPE_DELETE: u32 = 3;
pub const DPI_STMT_TYPE_INSERT: u32 = 4;
pub const DPI_STMT_TYPE_CREATE: u32 = 5;
pub const DPI_STMT_TYPE_DROP: u32 = 6;
pub const DPI_STMT_TYPE_ALTER: u32 = 7;
pub const DPI_STMT_TYPE_BEGIN: u32 = 8;
pub const DPI_STMT_TYPE_DECLARE: u32 = 9;
pub const DPI_STMT_TYPE_CALL: u32 = 10;
pub const DPI_STMT_TYPE_EXPLAIN_PLAN: u32 = 15;
pub const DPI_STMT_TYPE_MERGE: u32 = 16;
pub const DPI_STMT_TYPE_ROLLBACK: u32 = 17;
pub const DPI_STMT_TYPE_COMMIT: u32 = 21;
pub const DPI_SUBSCR_GROUPING_CLASS_TIME: u32 = 1;
pub const DPI_SUBSCR_GROUPING_TYPE_SUMMARY: u32 = 1;
pub const DPI_SUBSCR_GROUPING_TYPE_LAST: u32 = 2;
pub const DPI_SUBSCR_NAMESPACE_AQ: u32 = 1;
pub const DPI_SUBSCR_NAMESPACE_DBCHANGE: u32 = 2;
pub const DPI_SUBSCR_PROTO_CALLBACK: u32 = 0;
pub const DPI_SUBSCR_PROTO_MAIL: u32 = 1;
pub const DPI_SUBSCR_PROTO_PLSQL: u32 = 2;
pub const DPI_SUBSCR_PROTO_HTTP: u32 = 3;
pub const DPI_SUBSCR_QOS_RELIABLE: u32 = 1;
pub const DPI_SUBSCR_QOS_DEREG_NFY: u32 = 2;
pub const DPI_SUBSCR_QOS_ROWIDS: u32 = 4;
pub const DPI_SUBSCR_QOS_QUERY: u32 = 8;
pub const DPI_SUBSCR_QOS_BEST_EFFORT: u32 = 16;
pub const DPI_TPC_BEGIN_JOIN: u32 = 2;
pub const DPI_TPC_BEGIN_NEW: u32 = 1;
pub const DPI_TPC_BEGIN_PROMOTE: u32 = 8;
pub const DPI_TPC_BEGIN_RESUME: u32 = 4;
pub const DPI_TPC_END_NORMAL: u32 = 0;
pub const DPI_TPC_END_SUSPEND: u32 = 1048576;
pub const DPI_VISIBILITY_IMMEDIATE: u32 = 1;
pub const DPI_VISIBILITY_ON_COMMIT: u32 = 2;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type dpiAuthMode = u32;
pub type dpiConnCloseMode = u32;
pub type dpiCreateMode = u32;
pub type dpiDeqMode = u32;
pub type dpiDeqNavigation = u32;
pub type dpiEventType = u32;
pub type dpiExecMode = u32;
pub type dpiFetchMode = u16;
pub type dpiMessageDeliveryMode = u16;
pub type dpiMessageState = u32;
pub type dpiNativeTypeNum = u32;
pub type dpiOpCode = u32;
pub type dpiOracleTypeNum = u32;
pub type dpiPoolCloseMode = u32;
pub type dpiPoolGetMode = u8;
pub type dpiPurity = u32;
pub type dpiShutdownMode = u32;
pub type dpiStartupMode = u32;
pub type dpiStatementType = u16;
pub type dpiSubscrGroupingClass = u8;
pub type dpiSubscrGroupingType = u8;
pub type dpiSubscrNamespace = u32;
pub type dpiSubscrProtocol = u32;
pub type dpiSubscrQOS = u32;
pub type dpiTpcBeginFlags = u32;
pub type dpiTpcEndFlags = u32;
pub type dpiVisibility = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiConn {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiContext {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiDeqOptions {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiEnqOptions {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiJson {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiLob {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiMsgProps {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiObject {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiObjectAttr {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiObjectType {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiPool {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiQueue {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiRowid {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaColl {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaCollCursor {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaDb {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaDoc {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSodaDocCursor {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiStmt {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSubscr {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiVar {
    _unused: [u8; 0],
}
pub type dpiAccessTokenCallback = ::std::option::Option<
    unsafe extern "C" fn(
        context: *mut ::std::os::raw::c_void,
        accessToken: *mut dpiAccessToken,
    ) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiBytes {
    pub ptr: *mut ::std::os::raw::c_char,
    pub length: u32,
    pub encoding: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_dpiBytes() {
    assert_eq!(
        ::std::mem::size_of::<dpiBytes>(),
        24usize,
        concat!("Size of: ", stringify!(dpiBytes))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiBytes>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiBytes))
    );
    fn test_field_ptr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiBytes>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ptr) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiBytes),
                "::",
                stringify!(ptr)
            )
        );
    }
    test_field_ptr();
    fn test_field_length() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiBytes>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiBytes),
                "::",
                stringify!(length)
            )
        );
    }
    test_field_length();
    fn test_field_encoding() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiBytes>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiBytes),
                "::",
                stringify!(encoding)
            )
        );
    }
    test_field_encoding();
}
impl Default for dpiBytes {
    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 dpiIntervalDS {
    pub days: i32,
    pub hours: i32,
    pub minutes: i32,
    pub seconds: i32,
    pub fseconds: i32,
}
#[test]
fn bindgen_test_layout_dpiIntervalDS() {
    assert_eq!(
        ::std::mem::size_of::<dpiIntervalDS>(),
        20usize,
        concat!("Size of: ", stringify!(dpiIntervalDS))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiIntervalDS>(),
        4usize,
        concat!("Alignment of ", stringify!(dpiIntervalDS))
    );
    fn test_field_days() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiIntervalDS>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).days) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiIntervalDS),
                "::",
                stringify!(days)
            )
        );
    }
    test_field_days();
    fn test_field_hours() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiIntervalDS>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).hours) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiIntervalDS),
                "::",
                stringify!(hours)
            )
        );
    }
    test_field_hours();
    fn test_field_minutes() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiIntervalDS>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).minutes) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiIntervalDS),
                "::",
                stringify!(minutes)
            )
        );
    }
    test_field_minutes();
    fn test_field_seconds() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiIntervalDS>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).seconds) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiIntervalDS),
                "::",
                stringify!(seconds)
            )
        );
    }
    test_field_seconds();
    fn test_field_fseconds() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiIntervalDS>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fseconds) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiIntervalDS),
                "::",
                stringify!(fseconds)
            )
        );
    }
    test_field_fseconds();
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct dpiIntervalYM {
    pub years: i32,
    pub months: i32,
}
#[test]
fn bindgen_test_layout_dpiIntervalYM() {
    assert_eq!(
        ::std::mem::size_of::<dpiIntervalYM>(),
        8usize,
        concat!("Size of: ", stringify!(dpiIntervalYM))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiIntervalYM>(),
        4usize,
        concat!("Alignment of ", stringify!(dpiIntervalYM))
    );
    fn test_field_years() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiIntervalYM>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).years) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiIntervalYM),
                "::",
                stringify!(years)
            )
        );
    }
    test_field_years();
    fn test_field_months() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiIntervalYM>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).months) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiIntervalYM),
                "::",
                stringify!(months)
            )
        );
    }
    test_field_months();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiJsonNode {
    pub oracleTypeNum: dpiOracleTypeNum,
    pub nativeTypeNum: dpiNativeTypeNum,
    pub value: *mut dpiDataBuffer,
}
#[test]
fn bindgen_test_layout_dpiJsonNode() {
    assert_eq!(
        ::std::mem::size_of::<dpiJsonNode>(),
        16usize,
        concat!("Size of: ", stringify!(dpiJsonNode))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiJsonNode>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiJsonNode))
    );
    fn test_field_oracleTypeNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonNode>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).oracleTypeNum) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonNode),
                "::",
                stringify!(oracleTypeNum)
            )
        );
    }
    test_field_oracleTypeNum();
    fn test_field_nativeTypeNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonNode>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nativeTypeNum) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonNode),
                "::",
                stringify!(nativeTypeNum)
            )
        );
    }
    test_field_nativeTypeNum();
    fn test_field_value() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonNode>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonNode),
                "::",
                stringify!(value)
            )
        );
    }
    test_field_value();
}
impl Default for dpiJsonNode {
    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 dpiJsonObject {
    pub numFields: u32,
    pub fieldNames: *mut *mut ::std::os::raw::c_char,
    pub fieldNameLengths: *mut u32,
    pub fields: *mut dpiJsonNode,
    pub fieldValues: *mut dpiDataBuffer,
}
#[test]
fn bindgen_test_layout_dpiJsonObject() {
    assert_eq!(
        ::std::mem::size_of::<dpiJsonObject>(),
        40usize,
        concat!("Size of: ", stringify!(dpiJsonObject))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiJsonObject>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiJsonObject))
    );
    fn test_field_numFields() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonObject>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numFields) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonObject),
                "::",
                stringify!(numFields)
            )
        );
    }
    test_field_numFields();
    fn test_field_fieldNames() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonObject>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fieldNames) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonObject),
                "::",
                stringify!(fieldNames)
            )
        );
    }
    test_field_fieldNames();
    fn test_field_fieldNameLengths() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonObject>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fieldNameLengths) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonObject),
                "::",
                stringify!(fieldNameLengths)
            )
        );
    }
    test_field_fieldNameLengths();
    fn test_field_fields() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonObject>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fields) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonObject),
                "::",
                stringify!(fields)
            )
        );
    }
    test_field_fields();
    fn test_field_fieldValues() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonObject>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fieldValues) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonObject),
                "::",
                stringify!(fieldValues)
            )
        );
    }
    test_field_fieldValues();
}
impl Default for dpiJsonObject {
    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 dpiJsonArray {
    pub numElements: u32,
    pub elements: *mut dpiJsonNode,
    pub elementValues: *mut dpiDataBuffer,
}
#[test]
fn bindgen_test_layout_dpiJsonArray() {
    assert_eq!(
        ::std::mem::size_of::<dpiJsonArray>(),
        24usize,
        concat!("Size of: ", stringify!(dpiJsonArray))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiJsonArray>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiJsonArray))
    );
    fn test_field_numElements() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonArray>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numElements) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonArray),
                "::",
                stringify!(numElements)
            )
        );
    }
    test_field_numElements();
    fn test_field_elements() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonArray>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).elements) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonArray),
                "::",
                stringify!(elements)
            )
        );
    }
    test_field_elements();
    fn test_field_elementValues() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiJsonArray>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).elementValues) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiJsonArray),
                "::",
                stringify!(elementValues)
            )
        );
    }
    test_field_elementValues();
}
impl Default for dpiJsonArray {
    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 dpiTimestamp {
    pub year: i16,
    pub month: u8,
    pub day: u8,
    pub hour: u8,
    pub minute: u8,
    pub second: u8,
    pub fsecond: u32,
    pub tzHourOffset: i8,
    pub tzMinuteOffset: i8,
}
#[test]
fn bindgen_test_layout_dpiTimestamp() {
    assert_eq!(
        ::std::mem::size_of::<dpiTimestamp>(),
        16usize,
        concat!("Size of: ", stringify!(dpiTimestamp))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiTimestamp>(),
        4usize,
        concat!("Alignment of ", stringify!(dpiTimestamp))
    );
    fn test_field_year() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiTimestamp>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).year) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiTimestamp),
                "::",
                stringify!(year)
            )
        );
    }
    test_field_year();
    fn test_field_month() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiTimestamp>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).month) as usize - ptr as usize
            },
            2usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiTimestamp),
                "::",
                stringify!(month)
            )
        );
    }
    test_field_month();
    fn test_field_day() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiTimestamp>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).day) as usize - ptr as usize
            },
            3usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiTimestamp),
                "::",
                stringify!(day)
            )
        );
    }
    test_field_day();
    fn test_field_hour() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiTimestamp>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).hour) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiTimestamp),
                "::",
                stringify!(hour)
            )
        );
    }
    test_field_hour();
    fn test_field_minute() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiTimestamp>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).minute) as usize - ptr as usize
            },
            5usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiTimestamp),
                "::",
                stringify!(minute)
            )
        );
    }
    test_field_minute();
    fn test_field_second() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiTimestamp>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).second) as usize - ptr as usize
            },
            6usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiTimestamp),
                "::",
                stringify!(second)
            )
        );
    }
    test_field_second();
    fn test_field_fsecond() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiTimestamp>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fsecond) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiTimestamp),
                "::",
                stringify!(fsecond)
            )
        );
    }
    test_field_fsecond();
    fn test_field_tzHourOffset() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiTimestamp>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).tzHourOffset) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiTimestamp),
                "::",
                stringify!(tzHourOffset)
            )
        );
    }
    test_field_tzHourOffset();
    fn test_field_tzMinuteOffset() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiTimestamp>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).tzMinuteOffset) as usize - ptr as usize
            },
            13usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiTimestamp),
                "::",
                stringify!(tzMinuteOffset)
            )
        );
    }
    test_field_tzMinuteOffset();
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dpiDataBuffer {
    pub asBoolean: ::std::os::raw::c_int,
    pub asUint8: u8,
    pub asUint16: u16,
    pub asUint32: u32,
    pub asInt64: i64,
    pub asUint64: u64,
    pub asFloat: f32,
    pub asDouble: f64,
    pub asString: *mut ::std::os::raw::c_char,
    pub asRaw: *mut ::std::os::raw::c_void,
    pub asBytes: dpiBytes,
    pub asTimestamp: dpiTimestamp,
    pub asIntervalDS: dpiIntervalDS,
    pub asIntervalYM: dpiIntervalYM,
    pub asJson: *mut dpiJson,
    pub asJsonObject: dpiJsonObject,
    pub asJsonArray: dpiJsonArray,
    pub asLOB: *mut dpiLob,
    pub asObject: *mut dpiObject,
    pub asStmt: *mut dpiStmt,
    pub asRowid: *mut dpiRowid,
}
#[test]
fn bindgen_test_layout_dpiDataBuffer() {
    assert_eq!(
        ::std::mem::size_of::<dpiDataBuffer>(),
        40usize,
        concat!("Size of: ", stringify!(dpiDataBuffer))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiDataBuffer>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiDataBuffer))
    );
    fn test_field_asBoolean() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asBoolean) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asBoolean)
            )
        );
    }
    test_field_asBoolean();
    fn test_field_asUint8() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asUint8) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asUint8)
            )
        );
    }
    test_field_asUint8();
    fn test_field_asUint16() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asUint16) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asUint16)
            )
        );
    }
    test_field_asUint16();
    fn test_field_asUint32() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asUint32) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asUint32)
            )
        );
    }
    test_field_asUint32();
    fn test_field_asInt64() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asInt64) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asInt64)
            )
        );
    }
    test_field_asInt64();
    fn test_field_asUint64() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asUint64) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asUint64)
            )
        );
    }
    test_field_asUint64();
    fn test_field_asFloat() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asFloat) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asFloat)
            )
        );
    }
    test_field_asFloat();
    fn test_field_asDouble() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asDouble) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asDouble)
            )
        );
    }
    test_field_asDouble();
    fn test_field_asString() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asString) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asString)
            )
        );
    }
    test_field_asString();
    fn test_field_asRaw() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asRaw) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asRaw)
            )
        );
    }
    test_field_asRaw();
    fn test_field_asBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asBytes) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asBytes)
            )
        );
    }
    test_field_asBytes();
    fn test_field_asTimestamp() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asTimestamp) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asTimestamp)
            )
        );
    }
    test_field_asTimestamp();
    fn test_field_asIntervalDS() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asIntervalDS) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asIntervalDS)
            )
        );
    }
    test_field_asIntervalDS();
    fn test_field_asIntervalYM() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asIntervalYM) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asIntervalYM)
            )
        );
    }
    test_field_asIntervalYM();
    fn test_field_asJson() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asJson) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asJson)
            )
        );
    }
    test_field_asJson();
    fn test_field_asJsonObject() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asJsonObject) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asJsonObject)
            )
        );
    }
    test_field_asJsonObject();
    fn test_field_asJsonArray() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asJsonArray) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asJsonArray)
            )
        );
    }
    test_field_asJsonArray();
    fn test_field_asLOB() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asLOB) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asLOB)
            )
        );
    }
    test_field_asLOB();
    fn test_field_asObject() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asObject) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asObject)
            )
        );
    }
    test_field_asObject();
    fn test_field_asStmt() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asStmt) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asStmt)
            )
        );
    }
    test_field_asStmt();
    fn test_field_asRowid() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataBuffer>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).asRowid) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataBuffer),
                "::",
                stringify!(asRowid)
            )
        );
    }
    test_field_asRowid();
}
impl Default for dpiDataBuffer {
    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 dpiAppContext {
    pub namespaceName: *const ::std::os::raw::c_char,
    pub namespaceNameLength: u32,
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub value: *const ::std::os::raw::c_char,
    pub valueLength: u32,
}
#[test]
fn bindgen_test_layout_dpiAppContext() {
    assert_eq!(
        ::std::mem::size_of::<dpiAppContext>(),
        48usize,
        concat!("Size of: ", stringify!(dpiAppContext))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiAppContext>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiAppContext))
    );
    fn test_field_namespaceName() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiAppContext>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).namespaceName) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiAppContext),
                "::",
                stringify!(namespaceName)
            )
        );
    }
    test_field_namespaceName();
    fn test_field_namespaceNameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiAppContext>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).namespaceNameLength) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiAppContext),
                "::",
                stringify!(namespaceNameLength)
            )
        );
    }
    test_field_namespaceNameLength();
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiAppContext>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiAppContext),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_nameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiAppContext>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiAppContext),
                "::",
                stringify!(nameLength)
            )
        );
    }
    test_field_nameLength();
    fn test_field_value() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiAppContext>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiAppContext),
                "::",
                stringify!(value)
            )
        );
    }
    test_field_value();
    fn test_field_valueLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiAppContext>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).valueLength) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiAppContext),
                "::",
                stringify!(valueLength)
            )
        );
    }
    test_field_valueLength();
}
impl Default for dpiAppContext {
    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 dpiCommonCreateParams {
    pub createMode: dpiCreateMode,
    pub encoding: *const ::std::os::raw::c_char,
    pub nencoding: *const ::std::os::raw::c_char,
    pub edition: *const ::std::os::raw::c_char,
    pub editionLength: u32,
    pub driverName: *const ::std::os::raw::c_char,
    pub driverNameLength: u32,
    pub sodaMetadataCache: ::std::os::raw::c_int,
    pub stmtCacheSize: u32,
    pub accessToken: *mut dpiAccessToken,
}
#[test]
fn bindgen_test_layout_dpiCommonCreateParams() {
    assert_eq!(
        ::std::mem::size_of::<dpiCommonCreateParams>(),
        72usize,
        concat!("Size of: ", stringify!(dpiCommonCreateParams))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiCommonCreateParams>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiCommonCreateParams))
    );
    fn test_field_createMode() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiCommonCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).createMode) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiCommonCreateParams),
                "::",
                stringify!(createMode)
            )
        );
    }
    test_field_createMode();
    fn test_field_encoding() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiCommonCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiCommonCreateParams),
                "::",
                stringify!(encoding)
            )
        );
    }
    test_field_encoding();
    fn test_field_nencoding() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiCommonCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nencoding) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiCommonCreateParams),
                "::",
                stringify!(nencoding)
            )
        );
    }
    test_field_nencoding();
    fn test_field_edition() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiCommonCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).edition) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiCommonCreateParams),
                "::",
                stringify!(edition)
            )
        );
    }
    test_field_edition();
    fn test_field_editionLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiCommonCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).editionLength) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiCommonCreateParams),
                "::",
                stringify!(editionLength)
            )
        );
    }
    test_field_editionLength();
    fn test_field_driverName() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiCommonCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).driverName) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiCommonCreateParams),
                "::",
                stringify!(driverName)
            )
        );
    }
    test_field_driverName();
    fn test_field_driverNameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiCommonCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).driverNameLength) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiCommonCreateParams),
                "::",
                stringify!(driverNameLength)
            )
        );
    }
    test_field_driverNameLength();
    fn test_field_sodaMetadataCache() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiCommonCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).sodaMetadataCache) as usize - ptr as usize
            },
            52usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiCommonCreateParams),
                "::",
                stringify!(sodaMetadataCache)
            )
        );
    }
    test_field_sodaMetadataCache();
    fn test_field_stmtCacheSize() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiCommonCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).stmtCacheSize) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiCommonCreateParams),
                "::",
                stringify!(stmtCacheSize)
            )
        );
    }
    test_field_stmtCacheSize();
    fn test_field_accessToken() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiCommonCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).accessToken) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiCommonCreateParams),
                "::",
                stringify!(accessToken)
            )
        );
    }
    test_field_accessToken();
}
impl Default for dpiCommonCreateParams {
    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 dpiConnCreateParams {
    pub authMode: dpiAuthMode,
    pub connectionClass: *const ::std::os::raw::c_char,
    pub connectionClassLength: u32,
    pub purity: dpiPurity,
    pub newPassword: *const ::std::os::raw::c_char,
    pub newPasswordLength: u32,
    pub appContext: *mut dpiAppContext,
    pub numAppContext: u32,
    pub externalAuth: ::std::os::raw::c_int,
    pub externalHandle: *mut ::std::os::raw::c_void,
    pub pool: *mut dpiPool,
    pub tag: *const ::std::os::raw::c_char,
    pub tagLength: u32,
    pub matchAnyTag: ::std::os::raw::c_int,
    pub outTag: *const ::std::os::raw::c_char,
    pub outTagLength: u32,
    pub outTagFound: ::std::os::raw::c_int,
    pub shardingKeyColumns: *mut dpiShardingKeyColumn,
    pub numShardingKeyColumns: u8,
    pub superShardingKeyColumns: *mut dpiShardingKeyColumn,
    pub numSuperShardingKeyColumns: u8,
    pub outNewSession: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dpiConnCreateParams() {
    assert_eq!(
        ::std::mem::size_of::<dpiConnCreateParams>(),
        136usize,
        concat!("Size of: ", stringify!(dpiConnCreateParams))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiConnCreateParams>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiConnCreateParams))
    );
    fn test_field_authMode() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).authMode) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(authMode)
            )
        );
    }
    test_field_authMode();
    fn test_field_connectionClass() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).connectionClass) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(connectionClass)
            )
        );
    }
    test_field_connectionClass();
    fn test_field_connectionClassLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).connectionClassLength) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(connectionClassLength)
            )
        );
    }
    test_field_connectionClassLength();
    fn test_field_purity() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).purity) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(purity)
            )
        );
    }
    test_field_purity();
    fn test_field_newPassword() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).newPassword) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(newPassword)
            )
        );
    }
    test_field_newPassword();
    fn test_field_newPasswordLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).newPasswordLength) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(newPasswordLength)
            )
        );
    }
    test_field_newPasswordLength();
    fn test_field_appContext() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).appContext) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(appContext)
            )
        );
    }
    test_field_appContext();
    fn test_field_numAppContext() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numAppContext) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(numAppContext)
            )
        );
    }
    test_field_numAppContext();
    fn test_field_externalAuth() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).externalAuth) as usize - ptr as usize
            },
            52usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(externalAuth)
            )
        );
    }
    test_field_externalAuth();
    fn test_field_externalHandle() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).externalHandle) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(externalHandle)
            )
        );
    }
    test_field_externalHandle();
    fn test_field_pool() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pool) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(pool)
            )
        );
    }
    test_field_pool();
    fn test_field_tag() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).tag) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(tag)
            )
        );
    }
    test_field_tag();
    fn test_field_tagLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).tagLength) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(tagLength)
            )
        );
    }
    test_field_tagLength();
    fn test_field_matchAnyTag() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).matchAnyTag) as usize - ptr as usize
            },
            84usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(matchAnyTag)
            )
        );
    }
    test_field_matchAnyTag();
    fn test_field_outTag() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).outTag) as usize - ptr as usize
            },
            88usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(outTag)
            )
        );
    }
    test_field_outTag();
    fn test_field_outTagLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).outTagLength) as usize - ptr as usize
            },
            96usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(outTagLength)
            )
        );
    }
    test_field_outTagLength();
    fn test_field_outTagFound() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).outTagFound) as usize - ptr as usize
            },
            100usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(outTagFound)
            )
        );
    }
    test_field_outTagFound();
    fn test_field_shardingKeyColumns() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).shardingKeyColumns) as usize - ptr as usize
            },
            104usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(shardingKeyColumns)
            )
        );
    }
    test_field_shardingKeyColumns();
    fn test_field_numShardingKeyColumns() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numShardingKeyColumns) as usize - ptr as usize
            },
            112usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(numShardingKeyColumns)
            )
        );
    }
    test_field_numShardingKeyColumns();
    fn test_field_superShardingKeyColumns() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).superShardingKeyColumns) as usize - ptr as usize
            },
            120usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(superShardingKeyColumns)
            )
        );
    }
    test_field_superShardingKeyColumns();
    fn test_field_numSuperShardingKeyColumns() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numSuperShardingKeyColumns) as usize - ptr as usize
            },
            128usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(numSuperShardingKeyColumns)
            )
        );
    }
    test_field_numSuperShardingKeyColumns();
    fn test_field_outNewSession() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiConnCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).outNewSession) as usize - ptr as usize
            },
            132usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiConnCreateParams),
                "::",
                stringify!(outNewSession)
            )
        );
    }
    test_field_outNewSession();
}
impl Default for dpiConnCreateParams {
    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 dpiContextCreateParams {
    pub defaultDriverName: *const ::std::os::raw::c_char,
    pub defaultEncoding: *const ::std::os::raw::c_char,
    pub loadErrorUrl: *const ::std::os::raw::c_char,
    pub oracleClientLibDir: *const ::std::os::raw::c_char,
    pub oracleClientConfigDir: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_dpiContextCreateParams() {
    assert_eq!(
        ::std::mem::size_of::<dpiContextCreateParams>(),
        40usize,
        concat!("Size of: ", stringify!(dpiContextCreateParams))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiContextCreateParams>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiContextCreateParams))
    );
    fn test_field_defaultDriverName() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiContextCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).defaultDriverName) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiContextCreateParams),
                "::",
                stringify!(defaultDriverName)
            )
        );
    }
    test_field_defaultDriverName();
    fn test_field_defaultEncoding() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiContextCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).defaultEncoding) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiContextCreateParams),
                "::",
                stringify!(defaultEncoding)
            )
        );
    }
    test_field_defaultEncoding();
    fn test_field_loadErrorUrl() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiContextCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).loadErrorUrl) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiContextCreateParams),
                "::",
                stringify!(loadErrorUrl)
            )
        );
    }
    test_field_loadErrorUrl();
    fn test_field_oracleClientLibDir() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiContextCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).oracleClientLibDir) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiContextCreateParams),
                "::",
                stringify!(oracleClientLibDir)
            )
        );
    }
    test_field_oracleClientLibDir();
    fn test_field_oracleClientConfigDir() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiContextCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).oracleClientConfigDir) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiContextCreateParams),
                "::",
                stringify!(oracleClientConfigDir)
            )
        );
    }
    test_field_oracleClientConfigDir();
}
impl Default for dpiContextCreateParams {
    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(Copy, Clone)]
pub struct dpiData {
    pub isNull: ::std::os::raw::c_int,
    pub value: dpiDataBuffer,
}
#[test]
fn bindgen_test_layout_dpiData() {
    assert_eq!(
        ::std::mem::size_of::<dpiData>(),
        48usize,
        concat!("Size of: ", stringify!(dpiData))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiData>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiData))
    );
    fn test_field_isNull() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiData>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).isNull) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiData),
                "::",
                stringify!(isNull)
            )
        );
    }
    test_field_isNull();
    fn test_field_value() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiData>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiData),
                "::",
                stringify!(value)
            )
        );
    }
    test_field_value();
}
impl Default for dpiData {
    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 dpiDataTypeInfo {
    pub oracleTypeNum: dpiOracleTypeNum,
    pub defaultNativeTypeNum: dpiNativeTypeNum,
    pub ociTypeCode: u16,
    pub dbSizeInBytes: u32,
    pub clientSizeInBytes: u32,
    pub sizeInChars: u32,
    pub precision: i16,
    pub scale: i8,
    pub fsPrecision: u8,
    pub objectType: *mut dpiObjectType,
}
#[test]
fn bindgen_test_layout_dpiDataTypeInfo() {
    assert_eq!(
        ::std::mem::size_of::<dpiDataTypeInfo>(),
        40usize,
        concat!("Size of: ", stringify!(dpiDataTypeInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiDataTypeInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiDataTypeInfo))
    );
    fn test_field_oracleTypeNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).oracleTypeNum) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataTypeInfo),
                "::",
                stringify!(oracleTypeNum)
            )
        );
    }
    test_field_oracleTypeNum();
    fn test_field_defaultNativeTypeNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).defaultNativeTypeNum) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataTypeInfo),
                "::",
                stringify!(defaultNativeTypeNum)
            )
        );
    }
    test_field_defaultNativeTypeNum();
    fn test_field_ociTypeCode() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ociTypeCode) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataTypeInfo),
                "::",
                stringify!(ociTypeCode)
            )
        );
    }
    test_field_ociTypeCode();
    fn test_field_dbSizeInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).dbSizeInBytes) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataTypeInfo),
                "::",
                stringify!(dbSizeInBytes)
            )
        );
    }
    test_field_dbSizeInBytes();
    fn test_field_clientSizeInBytes() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).clientSizeInBytes) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataTypeInfo),
                "::",
                stringify!(clientSizeInBytes)
            )
        );
    }
    test_field_clientSizeInBytes();
    fn test_field_sizeInChars() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).sizeInChars) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataTypeInfo),
                "::",
                stringify!(sizeInChars)
            )
        );
    }
    test_field_sizeInChars();
    fn test_field_precision() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).precision) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataTypeInfo),
                "::",
                stringify!(precision)
            )
        );
    }
    test_field_precision();
    fn test_field_scale() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize
            },
            26usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataTypeInfo),
                "::",
                stringify!(scale)
            )
        );
    }
    test_field_scale();
    fn test_field_fsPrecision() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fsPrecision) as usize - ptr as usize
            },
            27usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataTypeInfo),
                "::",
                stringify!(fsPrecision)
            )
        );
    }
    test_field_fsPrecision();
    fn test_field_objectType() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiDataTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).objectType) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiDataTypeInfo),
                "::",
                stringify!(objectType)
            )
        );
    }
    test_field_objectType();
}
impl Default for dpiDataTypeInfo {
    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 dpiAccessToken {
    pub token: *const ::std::os::raw::c_char,
    pub tokenLength: u32,
    pub privateKey: *const ::std::os::raw::c_char,
    pub privateKeyLength: u32,
}
#[test]
fn bindgen_test_layout_dpiAccessToken() {
    assert_eq!(
        ::std::mem::size_of::<dpiAccessToken>(),
        32usize,
        concat!("Size of: ", stringify!(dpiAccessToken))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiAccessToken>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiAccessToken))
    );
    fn test_field_token() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiAccessToken>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiAccessToken),
                "::",
                stringify!(token)
            )
        );
    }
    test_field_token();
    fn test_field_tokenLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiAccessToken>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).tokenLength) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiAccessToken),
                "::",
                stringify!(tokenLength)
            )
        );
    }
    test_field_tokenLength();
    fn test_field_privateKey() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiAccessToken>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).privateKey) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiAccessToken),
                "::",
                stringify!(privateKey)
            )
        );
    }
    test_field_privateKey();
    fn test_field_privateKeyLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiAccessToken>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).privateKeyLength) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiAccessToken),
                "::",
                stringify!(privateKeyLength)
            )
        );
    }
    test_field_privateKeyLength();
}
impl Default for dpiAccessToken {
    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 dpiEncodingInfo {
    pub encoding: *const ::std::os::raw::c_char,
    pub maxBytesPerCharacter: i32,
    pub nencoding: *const ::std::os::raw::c_char,
    pub nmaxBytesPerCharacter: i32,
}
#[test]
fn bindgen_test_layout_dpiEncodingInfo() {
    assert_eq!(
        ::std::mem::size_of::<dpiEncodingInfo>(),
        32usize,
        concat!("Size of: ", stringify!(dpiEncodingInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiEncodingInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiEncodingInfo))
    );
    fn test_field_encoding() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiEncodingInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiEncodingInfo),
                "::",
                stringify!(encoding)
            )
        );
    }
    test_field_encoding();
    fn test_field_maxBytesPerCharacter() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiEncodingInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).maxBytesPerCharacter) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiEncodingInfo),
                "::",
                stringify!(maxBytesPerCharacter)
            )
        );
    }
    test_field_maxBytesPerCharacter();
    fn test_field_nencoding() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiEncodingInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nencoding) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiEncodingInfo),
                "::",
                stringify!(nencoding)
            )
        );
    }
    test_field_nencoding();
    fn test_field_nmaxBytesPerCharacter() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiEncodingInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nmaxBytesPerCharacter) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiEncodingInfo),
                "::",
                stringify!(nmaxBytesPerCharacter)
            )
        );
    }
    test_field_nmaxBytesPerCharacter();
}
impl Default for dpiEncodingInfo {
    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 dpiErrorInfo {
    pub code: i32,
    pub offset16: u16,
    pub message: *const ::std::os::raw::c_char,
    pub messageLength: u32,
    pub encoding: *const ::std::os::raw::c_char,
    pub fnName: *const ::std::os::raw::c_char,
    pub action: *const ::std::os::raw::c_char,
    pub sqlState: *const ::std::os::raw::c_char,
    pub isRecoverable: ::std::os::raw::c_int,
    pub isWarning: ::std::os::raw::c_int,
    pub offset: u32,
}
#[test]
fn bindgen_test_layout_dpiErrorInfo() {
    assert_eq!(
        ::std::mem::size_of::<dpiErrorInfo>(),
        72usize,
        concat!("Size of: ", stringify!(dpiErrorInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiErrorInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiErrorInfo))
    );
    fn test_field_code() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).code) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(code)
            )
        );
    }
    test_field_code();
    fn test_field_offset16() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).offset16) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(offset16)
            )
        );
    }
    test_field_offset16();
    fn test_field_message() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(message)
            )
        );
    }
    test_field_message();
    fn test_field_messageLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).messageLength) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(messageLength)
            )
        );
    }
    test_field_messageLength();
    fn test_field_encoding() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(encoding)
            )
        );
    }
    test_field_encoding();
    fn test_field_fnName() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fnName) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(fnName)
            )
        );
    }
    test_field_fnName();
    fn test_field_action() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(action)
            )
        );
    }
    test_field_action();
    fn test_field_sqlState() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).sqlState) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(sqlState)
            )
        );
    }
    test_field_sqlState();
    fn test_field_isRecoverable() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).isRecoverable) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(isRecoverable)
            )
        );
    }
    test_field_isRecoverable();
    fn test_field_isWarning() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).isWarning) as usize - ptr as usize
            },
            60usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(isWarning)
            )
        );
    }
    test_field_isWarning();
    fn test_field_offset() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiErrorInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiErrorInfo),
                "::",
                stringify!(offset)
            )
        );
    }
    test_field_offset();
}
impl Default for dpiErrorInfo {
    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 dpiObjectAttrInfo {
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub typeInfo: dpiDataTypeInfo,
}
#[test]
fn bindgen_test_layout_dpiObjectAttrInfo() {
    assert_eq!(
        ::std::mem::size_of::<dpiObjectAttrInfo>(),
        56usize,
        concat!("Size of: ", stringify!(dpiObjectAttrInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiObjectAttrInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiObjectAttrInfo))
    );
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectAttrInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectAttrInfo),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_nameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectAttrInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectAttrInfo),
                "::",
                stringify!(nameLength)
            )
        );
    }
    test_field_nameLength();
    fn test_field_typeInfo() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectAttrInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).typeInfo) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectAttrInfo),
                "::",
                stringify!(typeInfo)
            )
        );
    }
    test_field_typeInfo();
}
impl Default for dpiObjectAttrInfo {
    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 dpiObjectTypeInfo {
    pub schema: *const ::std::os::raw::c_char,
    pub schemaLength: u32,
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub isCollection: ::std::os::raw::c_int,
    pub elementTypeInfo: dpiDataTypeInfo,
    pub numAttributes: u16,
    pub packageName: *const ::std::os::raw::c_char,
    pub packageNameLength: u32,
}
#[test]
fn bindgen_test_layout_dpiObjectTypeInfo() {
    assert_eq!(
        ::std::mem::size_of::<dpiObjectTypeInfo>(),
        96usize,
        concat!("Size of: ", stringify!(dpiObjectTypeInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiObjectTypeInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiObjectTypeInfo))
    );
    fn test_field_schema() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).schema) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectTypeInfo),
                "::",
                stringify!(schema)
            )
        );
    }
    test_field_schema();
    fn test_field_schemaLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).schemaLength) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectTypeInfo),
                "::",
                stringify!(schemaLength)
            )
        );
    }
    test_field_schemaLength();
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectTypeInfo),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_nameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectTypeInfo),
                "::",
                stringify!(nameLength)
            )
        );
    }
    test_field_nameLength();
    fn test_field_isCollection() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).isCollection) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectTypeInfo),
                "::",
                stringify!(isCollection)
            )
        );
    }
    test_field_isCollection();
    fn test_field_elementTypeInfo() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).elementTypeInfo) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectTypeInfo),
                "::",
                stringify!(elementTypeInfo)
            )
        );
    }
    test_field_elementTypeInfo();
    fn test_field_numAttributes() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numAttributes) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectTypeInfo),
                "::",
                stringify!(numAttributes)
            )
        );
    }
    test_field_numAttributes();
    fn test_field_packageName() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).packageName) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectTypeInfo),
                "::",
                stringify!(packageName)
            )
        );
    }
    test_field_packageName();
    fn test_field_packageNameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiObjectTypeInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).packageNameLength) as usize - ptr as usize
            },
            88usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiObjectTypeInfo),
                "::",
                stringify!(packageNameLength)
            )
        );
    }
    test_field_packageNameLength();
}
impl Default for dpiObjectTypeInfo {
    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 dpiPoolCreateParams {
    pub minSessions: u32,
    pub maxSessions: u32,
    pub sessionIncrement: u32,
    pub pingInterval: ::std::os::raw::c_int,
    pub pingTimeout: ::std::os::raw::c_int,
    pub homogeneous: ::std::os::raw::c_int,
    pub externalAuth: ::std::os::raw::c_int,
    pub getMode: dpiPoolGetMode,
    pub outPoolName: *const ::std::os::raw::c_char,
    pub outPoolNameLength: u32,
    pub timeout: u32,
    pub waitTimeout: u32,
    pub maxLifetimeSession: u32,
    pub plsqlFixupCallback: *const ::std::os::raw::c_char,
    pub plsqlFixupCallbackLength: u32,
    pub maxSessionsPerShard: u32,
    pub accessTokenCallback: dpiAccessTokenCallback,
    pub accessTokenCallbackContext: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_dpiPoolCreateParams() {
    assert_eq!(
        ::std::mem::size_of::<dpiPoolCreateParams>(),
        88usize,
        concat!("Size of: ", stringify!(dpiPoolCreateParams))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiPoolCreateParams>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiPoolCreateParams))
    );
    fn test_field_minSessions() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).minSessions) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(minSessions)
            )
        );
    }
    test_field_minSessions();
    fn test_field_maxSessions() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).maxSessions) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(maxSessions)
            )
        );
    }
    test_field_maxSessions();
    fn test_field_sessionIncrement() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).sessionIncrement) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(sessionIncrement)
            )
        );
    }
    test_field_sessionIncrement();
    fn test_field_pingInterval() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pingInterval) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(pingInterval)
            )
        );
    }
    test_field_pingInterval();
    fn test_field_pingTimeout() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pingTimeout) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(pingTimeout)
            )
        );
    }
    test_field_pingTimeout();
    fn test_field_homogeneous() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).homogeneous) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(homogeneous)
            )
        );
    }
    test_field_homogeneous();
    fn test_field_externalAuth() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).externalAuth) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(externalAuth)
            )
        );
    }
    test_field_externalAuth();
    fn test_field_getMode() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).getMode) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(getMode)
            )
        );
    }
    test_field_getMode();
    fn test_field_outPoolName() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).outPoolName) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(outPoolName)
            )
        );
    }
    test_field_outPoolName();
    fn test_field_outPoolNameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).outPoolNameLength) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(outPoolNameLength)
            )
        );
    }
    test_field_outPoolNameLength();
    fn test_field_timeout() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize
            },
            44usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(timeout)
            )
        );
    }
    test_field_timeout();
    fn test_field_waitTimeout() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).waitTimeout) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(waitTimeout)
            )
        );
    }
    test_field_waitTimeout();
    fn test_field_maxLifetimeSession() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).maxLifetimeSession) as usize - ptr as usize
            },
            52usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(maxLifetimeSession)
            )
        );
    }
    test_field_maxLifetimeSession();
    fn test_field_plsqlFixupCallback() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).plsqlFixupCallback) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(plsqlFixupCallback)
            )
        );
    }
    test_field_plsqlFixupCallback();
    fn test_field_plsqlFixupCallbackLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).plsqlFixupCallbackLength) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(plsqlFixupCallbackLength)
            )
        );
    }
    test_field_plsqlFixupCallbackLength();
    fn test_field_maxSessionsPerShard() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).maxSessionsPerShard) as usize - ptr as usize
            },
            68usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(maxSessionsPerShard)
            )
        );
    }
    test_field_maxSessionsPerShard();
    fn test_field_accessTokenCallback() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).accessTokenCallback) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(accessTokenCallback)
            )
        );
    }
    test_field_accessTokenCallback();
    fn test_field_accessTokenCallbackContext() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiPoolCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).accessTokenCallbackContext) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiPoolCreateParams),
                "::",
                stringify!(accessTokenCallbackContext)
            )
        );
    }
    test_field_accessTokenCallbackContext();
}
impl Default for dpiPoolCreateParams {
    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 dpiQueryInfo {
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub typeInfo: dpiDataTypeInfo,
    pub nullOk: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dpiQueryInfo() {
    assert_eq!(
        ::std::mem::size_of::<dpiQueryInfo>(),
        64usize,
        concat!("Size of: ", stringify!(dpiQueryInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiQueryInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiQueryInfo))
    );
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiQueryInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiQueryInfo),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_nameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiQueryInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiQueryInfo),
                "::",
                stringify!(nameLength)
            )
        );
    }
    test_field_nameLength();
    fn test_field_typeInfo() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiQueryInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).typeInfo) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiQueryInfo),
                "::",
                stringify!(typeInfo)
            )
        );
    }
    test_field_typeInfo();
    fn test_field_nullOk() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiQueryInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nullOk) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiQueryInfo),
                "::",
                stringify!(nullOk)
            )
        );
    }
    test_field_nullOk();
}
impl Default for dpiQueryInfo {
    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 dpiMsgRecipient {
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
}
#[test]
fn bindgen_test_layout_dpiMsgRecipient() {
    assert_eq!(
        ::std::mem::size_of::<dpiMsgRecipient>(),
        16usize,
        concat!("Size of: ", stringify!(dpiMsgRecipient))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiMsgRecipient>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiMsgRecipient))
    );
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiMsgRecipient>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiMsgRecipient),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_nameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiMsgRecipient>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiMsgRecipient),
                "::",
                stringify!(nameLength)
            )
        );
    }
    test_field_nameLength();
}
impl Default for dpiMsgRecipient {
    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(Copy, Clone)]
pub struct dpiShardingKeyColumn {
    pub oracleTypeNum: dpiOracleTypeNum,
    pub nativeTypeNum: dpiNativeTypeNum,
    pub value: dpiDataBuffer,
}
#[test]
fn bindgen_test_layout_dpiShardingKeyColumn() {
    assert_eq!(
        ::std::mem::size_of::<dpiShardingKeyColumn>(),
        48usize,
        concat!("Size of: ", stringify!(dpiShardingKeyColumn))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiShardingKeyColumn>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiShardingKeyColumn))
    );
    fn test_field_oracleTypeNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiShardingKeyColumn>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).oracleTypeNum) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiShardingKeyColumn),
                "::",
                stringify!(oracleTypeNum)
            )
        );
    }
    test_field_oracleTypeNum();
    fn test_field_nativeTypeNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiShardingKeyColumn>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nativeTypeNum) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiShardingKeyColumn),
                "::",
                stringify!(nativeTypeNum)
            )
        );
    }
    test_field_nativeTypeNum();
    fn test_field_value() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiShardingKeyColumn>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiShardingKeyColumn),
                "::",
                stringify!(value)
            )
        );
    }
    test_field_value();
}
impl Default for dpiShardingKeyColumn {
    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 dpiSodaCollNames {
    pub numNames: u32,
    pub names: *mut *const ::std::os::raw::c_char,
    pub nameLengths: *mut u32,
}
#[test]
fn bindgen_test_layout_dpiSodaCollNames() {
    assert_eq!(
        ::std::mem::size_of::<dpiSodaCollNames>(),
        24usize,
        concat!("Size of: ", stringify!(dpiSodaCollNames))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSodaCollNames>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiSodaCollNames))
    );
    fn test_field_numNames() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaCollNames>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numNames) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaCollNames),
                "::",
                stringify!(numNames)
            )
        );
    }
    test_field_numNames();
    fn test_field_names() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaCollNames>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).names) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaCollNames),
                "::",
                stringify!(names)
            )
        );
    }
    test_field_names();
    fn test_field_nameLengths() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaCollNames>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nameLengths) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaCollNames),
                "::",
                stringify!(nameLengths)
            )
        );
    }
    test_field_nameLengths();
}
impl Default for dpiSodaCollNames {
    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 dpiSodaOperOptions {
    pub numKeys: u32,
    pub keys: *mut *const ::std::os::raw::c_char,
    pub keyLengths: *mut u32,
    pub key: *const ::std::os::raw::c_char,
    pub keyLength: u32,
    pub version: *const ::std::os::raw::c_char,
    pub versionLength: u32,
    pub filter: *const ::std::os::raw::c_char,
    pub filterLength: u32,
    pub skip: u32,
    pub limit: u32,
    pub fetchArraySize: u32,
    pub hint: *const ::std::os::raw::c_char,
    pub hintLength: u32,
}
#[test]
fn bindgen_test_layout_dpiSodaOperOptions() {
    assert_eq!(
        ::std::mem::size_of::<dpiSodaOperOptions>(),
        96usize,
        concat!("Size of: ", stringify!(dpiSodaOperOptions))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSodaOperOptions>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiSodaOperOptions))
    );
    fn test_field_numKeys() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numKeys) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(numKeys)
            )
        );
    }
    test_field_numKeys();
    fn test_field_keys() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).keys) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(keys)
            )
        );
    }
    test_field_keys();
    fn test_field_keyLengths() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).keyLengths) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(keyLengths)
            )
        );
    }
    test_field_keyLengths();
    fn test_field_key() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(key)
            )
        );
    }
    test_field_key();
    fn test_field_keyLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).keyLength) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(keyLength)
            )
        );
    }
    test_field_keyLength();
    fn test_field_version() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(version)
            )
        );
    }
    test_field_version();
    fn test_field_versionLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).versionLength) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(versionLength)
            )
        );
    }
    test_field_versionLength();
    fn test_field_filter() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).filter) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(filter)
            )
        );
    }
    test_field_filter();
    fn test_field_filterLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).filterLength) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(filterLength)
            )
        );
    }
    test_field_filterLength();
    fn test_field_skip() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).skip) as usize - ptr as usize
            },
            68usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(skip)
            )
        );
    }
    test_field_skip();
    fn test_field_limit() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).limit) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(limit)
            )
        );
    }
    test_field_limit();
    fn test_field_fetchArraySize() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fetchArraySize) as usize - ptr as usize
            },
            76usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(fetchArraySize)
            )
        );
    }
    test_field_fetchArraySize();
    fn test_field_hint() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).hint) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(hint)
            )
        );
    }
    test_field_hint();
    fn test_field_hintLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSodaOperOptions>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).hintLength) as usize - ptr as usize
            },
            88usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSodaOperOptions),
                "::",
                stringify!(hintLength)
            )
        );
    }
    test_field_hintLength();
}
impl Default for dpiSodaOperOptions {
    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 dpiStmtInfo {
    pub isQuery: ::std::os::raw::c_int,
    pub isPLSQL: ::std::os::raw::c_int,
    pub isDDL: ::std::os::raw::c_int,
    pub isDML: ::std::os::raw::c_int,
    pub statementType: dpiStatementType,
    pub isReturning: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dpiStmtInfo() {
    assert_eq!(
        ::std::mem::size_of::<dpiStmtInfo>(),
        24usize,
        concat!("Size of: ", stringify!(dpiStmtInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiStmtInfo>(),
        4usize,
        concat!("Alignment of ", stringify!(dpiStmtInfo))
    );
    fn test_field_isQuery() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiStmtInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).isQuery) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiStmtInfo),
                "::",
                stringify!(isQuery)
            )
        );
    }
    test_field_isQuery();
    fn test_field_isPLSQL() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiStmtInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).isPLSQL) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiStmtInfo),
                "::",
                stringify!(isPLSQL)
            )
        );
    }
    test_field_isPLSQL();
    fn test_field_isDDL() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiStmtInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).isDDL) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiStmtInfo),
                "::",
                stringify!(isDDL)
            )
        );
    }
    test_field_isDDL();
    fn test_field_isDML() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiStmtInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).isDML) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiStmtInfo),
                "::",
                stringify!(isDML)
            )
        );
    }
    test_field_isDML();
    fn test_field_statementType() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiStmtInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).statementType) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiStmtInfo),
                "::",
                stringify!(statementType)
            )
        );
    }
    test_field_statementType();
    fn test_field_isReturning() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiStmtInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).isReturning) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiStmtInfo),
                "::",
                stringify!(isReturning)
            )
        );
    }
    test_field_isReturning();
}
pub type dpiSubscrCallback = ::std::option::Option<
    unsafe extern "C" fn(context: *mut ::std::os::raw::c_void, message: *mut dpiSubscrMessage),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiSubscrCreateParams {
    pub subscrNamespace: dpiSubscrNamespace,
    pub protocol: dpiSubscrProtocol,
    pub qos: dpiSubscrQOS,
    pub operations: dpiOpCode,
    pub portNumber: u32,
    pub timeout: u32,
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub callback: dpiSubscrCallback,
    pub callbackContext: *mut ::std::os::raw::c_void,
    pub recipientName: *const ::std::os::raw::c_char,
    pub recipientNameLength: u32,
    pub ipAddress: *const ::std::os::raw::c_char,
    pub ipAddressLength: u32,
    pub groupingClass: u8,
    pub groupingValue: u32,
    pub groupingType: u8,
    pub outRegId: u64,
    pub clientInitiated: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dpiSubscrCreateParams() {
    assert_eq!(
        ::std::mem::size_of::<dpiSubscrCreateParams>(),
        112usize,
        concat!("Size of: ", stringify!(dpiSubscrCreateParams))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSubscrCreateParams>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiSubscrCreateParams))
    );
    fn test_field_subscrNamespace() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).subscrNamespace) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(subscrNamespace)
            )
        );
    }
    test_field_subscrNamespace();
    fn test_field_protocol() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).protocol) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(protocol)
            )
        );
    }
    test_field_protocol();
    fn test_field_qos() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).qos) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(qos)
            )
        );
    }
    test_field_qos();
    fn test_field_operations() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).operations) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(operations)
            )
        );
    }
    test_field_operations();
    fn test_field_portNumber() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).portNumber) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(portNumber)
            )
        );
    }
    test_field_portNumber();
    fn test_field_timeout() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(timeout)
            )
        );
    }
    test_field_timeout();
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_nameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(nameLength)
            )
        );
    }
    test_field_nameLength();
    fn test_field_callback() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).callback) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(callback)
            )
        );
    }
    test_field_callback();
    fn test_field_callbackContext() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).callbackContext) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(callbackContext)
            )
        );
    }
    test_field_callbackContext();
    fn test_field_recipientName() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).recipientName) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(recipientName)
            )
        );
    }
    test_field_recipientName();
    fn test_field_recipientNameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).recipientNameLength) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(recipientNameLength)
            )
        );
    }
    test_field_recipientNameLength();
    fn test_field_ipAddress() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ipAddress) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(ipAddress)
            )
        );
    }
    test_field_ipAddress();
    fn test_field_ipAddressLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ipAddressLength) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(ipAddressLength)
            )
        );
    }
    test_field_ipAddressLength();
    fn test_field_groupingClass() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).groupingClass) as usize - ptr as usize
            },
            84usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(groupingClass)
            )
        );
    }
    test_field_groupingClass();
    fn test_field_groupingValue() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).groupingValue) as usize - ptr as usize
            },
            88usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(groupingValue)
            )
        );
    }
    test_field_groupingValue();
    fn test_field_groupingType() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).groupingType) as usize - ptr as usize
            },
            92usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(groupingType)
            )
        );
    }
    test_field_groupingType();
    fn test_field_outRegId() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).outRegId) as usize - ptr as usize
            },
            96usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(outRegId)
            )
        );
    }
    test_field_outRegId();
    fn test_field_clientInitiated() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrCreateParams>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).clientInitiated) as usize - ptr as usize
            },
            104usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrCreateParams),
                "::",
                stringify!(clientInitiated)
            )
        );
    }
    test_field_clientInitiated();
}
impl Default for dpiSubscrCreateParams {
    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 dpiSubscrMessage {
    pub eventType: dpiEventType,
    pub dbName: *const ::std::os::raw::c_char,
    pub dbNameLength: u32,
    pub tables: *mut dpiSubscrMessageTable,
    pub numTables: u32,
    pub queries: *mut dpiSubscrMessageQuery,
    pub numQueries: u32,
    pub errorInfo: *mut dpiErrorInfo,
    pub txId: *const ::std::os::raw::c_void,
    pub txIdLength: u32,
    pub registered: ::std::os::raw::c_int,
    pub queueName: *const ::std::os::raw::c_char,
    pub queueNameLength: u32,
    pub consumerName: *const ::std::os::raw::c_char,
    pub consumerNameLength: u32,
    pub aqMsgId: *const ::std::os::raw::c_void,
    pub aqMsgIdLength: u32,
}
#[test]
fn bindgen_test_layout_dpiSubscrMessage() {
    assert_eq!(
        ::std::mem::size_of::<dpiSubscrMessage>(),
        128usize,
        concat!("Size of: ", stringify!(dpiSubscrMessage))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSubscrMessage>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiSubscrMessage))
    );
    fn test_field_eventType() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).eventType) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(eventType)
            )
        );
    }
    test_field_eventType();
    fn test_field_dbName() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).dbName) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(dbName)
            )
        );
    }
    test_field_dbName();
    fn test_field_dbNameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).dbNameLength) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(dbNameLength)
            )
        );
    }
    test_field_dbNameLength();
    fn test_field_tables() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).tables) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(tables)
            )
        );
    }
    test_field_tables();
    fn test_field_numTables() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numTables) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(numTables)
            )
        );
    }
    test_field_numTables();
    fn test_field_queries() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).queries) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(queries)
            )
        );
    }
    test_field_queries();
    fn test_field_numQueries() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numQueries) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(numQueries)
            )
        );
    }
    test_field_numQueries();
    fn test_field_errorInfo() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).errorInfo) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(errorInfo)
            )
        );
    }
    test_field_errorInfo();
    fn test_field_txId() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).txId) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(txId)
            )
        );
    }
    test_field_txId();
    fn test_field_txIdLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).txIdLength) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(txIdLength)
            )
        );
    }
    test_field_txIdLength();
    fn test_field_registered() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).registered) as usize - ptr as usize
            },
            76usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(registered)
            )
        );
    }
    test_field_registered();
    fn test_field_queueName() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).queueName) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(queueName)
            )
        );
    }
    test_field_queueName();
    fn test_field_queueNameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).queueNameLength) as usize - ptr as usize
            },
            88usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(queueNameLength)
            )
        );
    }
    test_field_queueNameLength();
    fn test_field_consumerName() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).consumerName) as usize - ptr as usize
            },
            96usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(consumerName)
            )
        );
    }
    test_field_consumerName();
    fn test_field_consumerNameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).consumerNameLength) as usize - ptr as usize
            },
            104usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(consumerNameLength)
            )
        );
    }
    test_field_consumerNameLength();
    fn test_field_aqMsgId() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).aqMsgId) as usize - ptr as usize
            },
            112usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(aqMsgId)
            )
        );
    }
    test_field_aqMsgId();
    fn test_field_aqMsgIdLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessage>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).aqMsgIdLength) as usize - ptr as usize
            },
            120usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessage),
                "::",
                stringify!(aqMsgIdLength)
            )
        );
    }
    test_field_aqMsgIdLength();
}
impl Default for dpiSubscrMessage {
    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 dpiSubscrMessageQuery {
    pub id: u64,
    pub operation: dpiOpCode,
    pub tables: *mut dpiSubscrMessageTable,
    pub numTables: u32,
}
#[test]
fn bindgen_test_layout_dpiSubscrMessageQuery() {
    assert_eq!(
        ::std::mem::size_of::<dpiSubscrMessageQuery>(),
        32usize,
        concat!("Size of: ", stringify!(dpiSubscrMessageQuery))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSubscrMessageQuery>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiSubscrMessageQuery))
    );
    fn test_field_id() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageQuery>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageQuery),
                "::",
                stringify!(id)
            )
        );
    }
    test_field_id();
    fn test_field_operation() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageQuery>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageQuery),
                "::",
                stringify!(operation)
            )
        );
    }
    test_field_operation();
    fn test_field_tables() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageQuery>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).tables) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageQuery),
                "::",
                stringify!(tables)
            )
        );
    }
    test_field_tables();
    fn test_field_numTables() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageQuery>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numTables) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageQuery),
                "::",
                stringify!(numTables)
            )
        );
    }
    test_field_numTables();
}
impl Default for dpiSubscrMessageQuery {
    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 dpiSubscrMessageRow {
    pub operation: dpiOpCode,
    pub rowid: *const ::std::os::raw::c_char,
    pub rowidLength: u32,
}
#[test]
fn bindgen_test_layout_dpiSubscrMessageRow() {
    assert_eq!(
        ::std::mem::size_of::<dpiSubscrMessageRow>(),
        24usize,
        concat!("Size of: ", stringify!(dpiSubscrMessageRow))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSubscrMessageRow>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiSubscrMessageRow))
    );
    fn test_field_operation() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageRow>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageRow),
                "::",
                stringify!(operation)
            )
        );
    }
    test_field_operation();
    fn test_field_rowid() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageRow>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).rowid) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageRow),
                "::",
                stringify!(rowid)
            )
        );
    }
    test_field_rowid();
    fn test_field_rowidLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageRow>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).rowidLength) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageRow),
                "::",
                stringify!(rowidLength)
            )
        );
    }
    test_field_rowidLength();
}
impl Default for dpiSubscrMessageRow {
    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 dpiSubscrMessageTable {
    pub operation: dpiOpCode,
    pub name: *const ::std::os::raw::c_char,
    pub nameLength: u32,
    pub rows: *mut dpiSubscrMessageRow,
    pub numRows: u32,
}
#[test]
fn bindgen_test_layout_dpiSubscrMessageTable() {
    assert_eq!(
        ::std::mem::size_of::<dpiSubscrMessageTable>(),
        40usize,
        concat!("Size of: ", stringify!(dpiSubscrMessageTable))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiSubscrMessageTable>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiSubscrMessageTable))
    );
    fn test_field_operation() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageTable>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageTable),
                "::",
                stringify!(operation)
            )
        );
    }
    test_field_operation();
    fn test_field_name() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageTable>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageTable),
                "::",
                stringify!(name)
            )
        );
    }
    test_field_name();
    fn test_field_nameLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageTable>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nameLength) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageTable),
                "::",
                stringify!(nameLength)
            )
        );
    }
    test_field_nameLength();
    fn test_field_rows() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageTable>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).rows) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageTable),
                "::",
                stringify!(rows)
            )
        );
    }
    test_field_rows();
    fn test_field_numRows() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiSubscrMessageTable>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).numRows) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiSubscrMessageTable),
                "::",
                stringify!(numRows)
            )
        );
    }
    test_field_numRows();
}
impl Default for dpiSubscrMessageTable {
    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 dpiVersionInfo {
    pub versionNum: ::std::os::raw::c_int,
    pub releaseNum: ::std::os::raw::c_int,
    pub updateNum: ::std::os::raw::c_int,
    pub portReleaseNum: ::std::os::raw::c_int,
    pub portUpdateNum: ::std::os::raw::c_int,
    pub fullVersionNum: u32,
}
#[test]
fn bindgen_test_layout_dpiVersionInfo() {
    assert_eq!(
        ::std::mem::size_of::<dpiVersionInfo>(),
        24usize,
        concat!("Size of: ", stringify!(dpiVersionInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiVersionInfo>(),
        4usize,
        concat!("Alignment of ", stringify!(dpiVersionInfo))
    );
    fn test_field_versionNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiVersionInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).versionNum) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiVersionInfo),
                "::",
                stringify!(versionNum)
            )
        );
    }
    test_field_versionNum();
    fn test_field_releaseNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiVersionInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).releaseNum) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiVersionInfo),
                "::",
                stringify!(releaseNum)
            )
        );
    }
    test_field_releaseNum();
    fn test_field_updateNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiVersionInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).updateNum) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiVersionInfo),
                "::",
                stringify!(updateNum)
            )
        );
    }
    test_field_updateNum();
    fn test_field_portReleaseNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiVersionInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).portReleaseNum) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiVersionInfo),
                "::",
                stringify!(portReleaseNum)
            )
        );
    }
    test_field_portReleaseNum();
    fn test_field_portUpdateNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiVersionInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).portUpdateNum) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiVersionInfo),
                "::",
                stringify!(portUpdateNum)
            )
        );
    }
    test_field_portUpdateNum();
    fn test_field_fullVersionNum() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiVersionInfo>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fullVersionNum) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiVersionInfo),
                "::",
                stringify!(fullVersionNum)
            )
        );
    }
    test_field_fullVersionNum();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dpiXid {
    pub formatId: ::std::os::raw::c_long,
    pub globalTransactionId: *const ::std::os::raw::c_char,
    pub globalTransactionIdLength: u32,
    pub branchQualifier: *const ::std::os::raw::c_char,
    pub branchQualifierLength: u32,
}
#[test]
fn bindgen_test_layout_dpiXid() {
    assert_eq!(
        ::std::mem::size_of::<dpiXid>(),
        40usize,
        concat!("Size of: ", stringify!(dpiXid))
    );
    assert_eq!(
        ::std::mem::align_of::<dpiXid>(),
        8usize,
        concat!("Alignment of ", stringify!(dpiXid))
    );
    fn test_field_formatId() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiXid>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).formatId) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiXid),
                "::",
                stringify!(formatId)
            )
        );
    }
    test_field_formatId();
    fn test_field_globalTransactionId() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiXid>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).globalTransactionId) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiXid),
                "::",
                stringify!(globalTransactionId)
            )
        );
    }
    test_field_globalTransactionId();
    fn test_field_globalTransactionIdLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiXid>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).globalTransactionIdLength) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiXid),
                "::",
                stringify!(globalTransactionIdLength)
            )
        );
    }
    test_field_globalTransactionIdLength();
    fn test_field_branchQualifier() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiXid>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).branchQualifier) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiXid),
                "::",
                stringify!(branchQualifier)
            )
        );
    }
    test_field_branchQualifier();
    fn test_field_branchQualifierLength() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<dpiXid>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).branchQualifierLength) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(dpiXid),
                "::",
                stringify!(branchQualifierLength)
            )
        );
    }
    test_field_branchQualifierLength();
}
impl Default for dpiXid {
    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 dpiContext_createWithParams(
        majorVersion: ::std::os::raw::c_uint,
        minorVersion: ::std::os::raw::c_uint,
        params: *mut dpiContextCreateParams,
        context: *mut *mut dpiContext,
        errorInfo: *mut dpiErrorInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_destroy(context: *mut dpiContext) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_getClientVersion(
        context: *const dpiContext,
        versionInfo: *mut dpiVersionInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_getError(context: *const dpiContext, errorInfo: *mut dpiErrorInfo);
}
extern "C" {
    pub fn dpiContext_initCommonCreateParams(
        context: *const dpiContext,
        params: *mut dpiCommonCreateParams,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_initConnCreateParams(
        context: *const dpiContext,
        params: *mut dpiConnCreateParams,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_initPoolCreateParams(
        context: *const dpiContext,
        params: *mut dpiPoolCreateParams,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_initSodaOperOptions(
        context: *const dpiContext,
        options: *mut dpiSodaOperOptions,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiContext_initSubscrCreateParams(
        context: *const dpiContext,
        params: *mut dpiSubscrCreateParams,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_addRef(conn: *mut dpiConn) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_beginDistribTrans(
        conn: *mut dpiConn,
        formatId: ::std::os::raw::c_long,
        globalTransactionId: *const ::std::os::raw::c_char,
        globalTransactionIdLength: u32,
        branchQualifier: *const ::std::os::raw::c_char,
        branchQualifierLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_breakExecution(conn: *mut dpiConn) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_changePassword(
        conn: *mut dpiConn,
        userName: *const ::std::os::raw::c_char,
        userNameLength: u32,
        oldPassword: *const ::std::os::raw::c_char,
        oldPasswordLength: u32,
        newPassword: *const ::std::os::raw::c_char,
        newPasswordLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_close(
        conn: *mut dpiConn,
        mode: dpiConnCloseMode,
        tag: *const ::std::os::raw::c_char,
        tagLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_commit(conn: *mut dpiConn) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_create(
        context: *const dpiContext,
        userName: *const ::std::os::raw::c_char,
        userNameLength: u32,
        password: *const ::std::os::raw::c_char,
        passwordLength: u32,
        connectString: *const ::std::os::raw::c_char,
        connectStringLength: u32,
        commonParams: *const dpiCommonCreateParams,
        createParams: *mut dpiConnCreateParams,
        conn: *mut *mut dpiConn,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_deqObject(
        conn: *mut dpiConn,
        queueName: *const ::std::os::raw::c_char,
        queueNameLength: u32,
        options: *mut dpiDeqOptions,
        props: *mut dpiMsgProps,
        payload: *mut dpiObject,
        msgId: *mut *const ::std::os::raw::c_char,
        msgIdLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_enqObject(
        conn: *mut dpiConn,
        queueName: *const ::std::os::raw::c_char,
        queueNameLength: u32,
        options: *mut dpiEnqOptions,
        props: *mut dpiMsgProps,
        payload: *mut dpiObject,
        msgId: *mut *const ::std::os::raw::c_char,
        msgIdLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getCallTimeout(conn: *mut dpiConn, value: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getCurrentSchema(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getEdition(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getEncodingInfo(
        conn: *mut dpiConn,
        info: *mut dpiEncodingInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getExternalName(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getHandle(
        conn: *mut dpiConn,
        handle: *mut *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getInternalName(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getIsHealthy(
        conn: *mut dpiConn,
        isHealthy: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getLTXID(
        conn: *mut dpiConn,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getObjectType(
        conn: *mut dpiConn,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        objType: *mut *mut dpiObjectType,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getOciAttr(
        conn: *mut dpiConn,
        handleType: u32,
        attribute: u32,
        value: *mut dpiDataBuffer,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getServerVersion(
        conn: *mut dpiConn,
        releaseString: *mut *const ::std::os::raw::c_char,
        releaseStringLength: *mut u32,
        versionInfo: *mut dpiVersionInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getSodaDb(conn: *mut dpiConn, db: *mut *mut dpiSodaDb) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_getStmtCacheSize(
        conn: *mut dpiConn,
        cacheSize: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newDeqOptions(
        conn: *mut dpiConn,
        options: *mut *mut dpiDeqOptions,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newEnqOptions(
        conn: *mut dpiConn,
        options: *mut *mut dpiEnqOptions,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newJson(conn: *mut dpiConn, json: *mut *mut dpiJson) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newJsonQueue(
        conn: *mut dpiConn,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        queue: *mut *mut dpiQueue,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newMsgProps(
        conn: *mut dpiConn,
        props: *mut *mut dpiMsgProps,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newQueue(
        conn: *mut dpiConn,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        payloadType: *mut dpiObjectType,
        queue: *mut *mut dpiQueue,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newTempLob(
        conn: *mut dpiConn,
        lobType: dpiOracleTypeNum,
        lob: *mut *mut dpiLob,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_newVar(
        conn: *mut dpiConn,
        oracleTypeNum: dpiOracleTypeNum,
        nativeTypeNum: dpiNativeTypeNum,
        maxArraySize: u32,
        size: u32,
        sizeIsBytes: ::std::os::raw::c_int,
        isArray: ::std::os::raw::c_int,
        objType: *mut dpiObjectType,
        var: *mut *mut dpiVar,
        data: *mut *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_ping(conn: *mut dpiConn) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_prepareDistribTrans(
        conn: *mut dpiConn,
        commitNeeded: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_prepareStmt(
        conn: *mut dpiConn,
        scrollable: ::std::os::raw::c_int,
        sql: *const ::std::os::raw::c_char,
        sqlLength: u32,
        tag: *const ::std::os::raw::c_char,
        tagLength: u32,
        stmt: *mut *mut dpiStmt,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_release(conn: *mut dpiConn) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_rollback(conn: *mut dpiConn) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setAction(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setCallTimeout(conn: *mut dpiConn, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setClientIdentifier(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setClientInfo(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setCurrentSchema(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setDbOp(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setEcontextId(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setExternalName(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setInternalName(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setModule(
        conn: *mut dpiConn,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setOciAttr(
        conn: *mut dpiConn,
        handleType: u32,
        attribute: u32,
        value: *mut ::std::os::raw::c_void,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_setStmtCacheSize(conn: *mut dpiConn, cacheSize: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_shutdownDatabase(
        conn: *mut dpiConn,
        mode: dpiShutdownMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_startupDatabase(
        conn: *mut dpiConn,
        mode: dpiStartupMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_startupDatabaseWithPfile(
        conn: *mut dpiConn,
        pfile: *const ::std::os::raw::c_char,
        pfileLength: u32,
        mode: dpiStartupMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_subscribe(
        conn: *mut dpiConn,
        params: *mut dpiSubscrCreateParams,
        subscr: *mut *mut dpiSubscr,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_tpcBegin(
        conn: *mut dpiConn,
        xid: *mut dpiXid,
        transactionTimeout: u32,
        flags: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_tpcCommit(
        conn: *mut dpiConn,
        xid: *mut dpiXid,
        onePhase: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_tpcEnd(
        conn: *mut dpiConn,
        xid: *mut dpiXid,
        flags: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_tpcForget(conn: *mut dpiConn, xid: *mut dpiXid) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_tpcPrepare(
        conn: *mut dpiConn,
        xid: *mut dpiXid,
        commitNeeded: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_tpcRollback(conn: *mut dpiConn, xid: *mut dpiXid) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiConn_unsubscribe(conn: *mut dpiConn, subscr: *mut dpiSubscr)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiData_getBool(data: *mut dpiData) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiData_getBytes(data: *mut dpiData) -> *mut dpiBytes;
}
extern "C" {
    pub fn dpiData_getDouble(data: *mut dpiData) -> f64;
}
extern "C" {
    pub fn dpiData_getFloat(data: *mut dpiData) -> f32;
}
extern "C" {
    pub fn dpiData_getInt64(data: *mut dpiData) -> i64;
}
extern "C" {
    pub fn dpiData_getIntervalDS(data: *mut dpiData) -> *mut dpiIntervalDS;
}
extern "C" {
    pub fn dpiData_getIntervalYM(data: *mut dpiData) -> *mut dpiIntervalYM;
}
extern "C" {
    pub fn dpiData_getIsNull(data: *mut dpiData) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiData_getJson(data: *mut dpiData) -> *mut dpiJson;
}
extern "C" {
    pub fn dpiData_getJsonArray(data: *mut dpiData) -> *mut dpiJsonArray;
}
extern "C" {
    pub fn dpiData_getJsonObject(data: *mut dpiData) -> *mut dpiJsonObject;
}
extern "C" {
    pub fn dpiData_getLOB(data: *mut dpiData) -> *mut dpiLob;
}
extern "C" {
    pub fn dpiData_getObject(data: *mut dpiData) -> *mut dpiObject;
}
extern "C" {
    pub fn dpiData_getStmt(data: *mut dpiData) -> *mut dpiStmt;
}
extern "C" {
    pub fn dpiData_getTimestamp(data: *mut dpiData) -> *mut dpiTimestamp;
}
extern "C" {
    pub fn dpiData_getUint64(data: *mut dpiData) -> u64;
}
extern "C" {
    pub fn dpiData_setBool(data: *mut dpiData, value: ::std::os::raw::c_int);
}
extern "C" {
    pub fn dpiData_setBytes(data: *mut dpiData, ptr: *mut ::std::os::raw::c_char, length: u32);
}
extern "C" {
    pub fn dpiData_setDouble(data: *mut dpiData, value: f64);
}
extern "C" {
    pub fn dpiData_setFloat(data: *mut dpiData, value: f32);
}
extern "C" {
    pub fn dpiData_setInt64(data: *mut dpiData, value: i64);
}
extern "C" {
    pub fn dpiData_setIntervalDS(
        data: *mut dpiData,
        days: i32,
        hours: i32,
        minutes: i32,
        seconds: i32,
        fsceconds: i32,
    );
}
extern "C" {
    pub fn dpiData_setIntervalYM(data: *mut dpiData, years: i32, months: i32);
}
extern "C" {
    pub fn dpiData_setLOB(data: *mut dpiData, lob: *mut dpiLob);
}
extern "C" {
    pub fn dpiData_setNull(data: *mut dpiData);
}
extern "C" {
    pub fn dpiData_setObject(data: *mut dpiData, obj: *mut dpiObject);
}
extern "C" {
    pub fn dpiData_setStmt(data: *mut dpiData, stmt: *mut dpiStmt);
}
extern "C" {
    pub fn dpiData_setTimestamp(
        data: *mut dpiData,
        year: i16,
        month: u8,
        day: u8,
        hour: u8,
        minute: u8,
        second: u8,
        fsecond: u32,
        tzHourOffset: i8,
        tzMinuteOffset: i8,
    );
}
extern "C" {
    pub fn dpiData_setUint64(data: *mut dpiData, value: u64);
}
extern "C" {
    pub fn dpiDeqOptions_addRef(options: *mut dpiDeqOptions) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getCondition(
        options: *mut dpiDeqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getConsumerName(
        options: *mut dpiDeqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getCorrelation(
        options: *mut dpiDeqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getMode(
        options: *mut dpiDeqOptions,
        value: *mut dpiDeqMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getMsgId(
        options: *mut dpiDeqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getNavigation(
        options: *mut dpiDeqOptions,
        value: *mut dpiDeqNavigation,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getTransformation(
        options: *mut dpiDeqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getVisibility(
        options: *mut dpiDeqOptions,
        value: *mut dpiVisibility,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_getWait(
        options: *mut dpiDeqOptions,
        value: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_release(options: *mut dpiDeqOptions) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setCondition(
        options: *mut dpiDeqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setConsumerName(
        options: *mut dpiDeqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setCorrelation(
        options: *mut dpiDeqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setDeliveryMode(
        options: *mut dpiDeqOptions,
        value: dpiMessageDeliveryMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setMode(
        options: *mut dpiDeqOptions,
        value: dpiDeqMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setMsgId(
        options: *mut dpiDeqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setNavigation(
        options: *mut dpiDeqOptions,
        value: dpiDeqNavigation,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setTransformation(
        options: *mut dpiDeqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setVisibility(
        options: *mut dpiDeqOptions,
        value: dpiVisibility,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiDeqOptions_setWait(options: *mut dpiDeqOptions, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_addRef(options: *mut dpiEnqOptions) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_getTransformation(
        options: *mut dpiEnqOptions,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_getVisibility(
        options: *mut dpiEnqOptions,
        value: *mut dpiVisibility,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_release(options: *mut dpiEnqOptions) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_setDeliveryMode(
        options: *mut dpiEnqOptions,
        value: dpiMessageDeliveryMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_setTransformation(
        options: *mut dpiEnqOptions,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiEnqOptions_setVisibility(
        options: *mut dpiEnqOptions,
        value: dpiVisibility,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiJson_addRef(json: *mut dpiJson) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiJson_getValue(
        json: *mut dpiJson,
        options: u32,
        topNode: *mut *mut dpiJsonNode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiJson_release(json: *mut dpiJson) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiJson_setFromText(
        json: *mut dpiJson,
        value: *const ::std::os::raw::c_char,
        valueLength: u64,
        flags: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiJson_setValue(json: *mut dpiJson, topNode: *mut dpiJsonNode)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_addRef(lob: *mut dpiLob) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_close(lob: *mut dpiLob) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_closeResource(lob: *mut dpiLob) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_copy(lob: *mut dpiLob, copiedLob: *mut *mut dpiLob) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_getBufferSize(
        lob: *mut dpiLob,
        sizeInChars: u64,
        sizeInBytes: *mut u64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_getChunkSize(lob: *mut dpiLob, size: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_getDirectoryAndFileName(
        lob: *mut dpiLob,
        directoryAlias: *mut *const ::std::os::raw::c_char,
        directoryAliasLength: *mut u32,
        fileName: *mut *const ::std::os::raw::c_char,
        fileNameLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_getFileExists(
        lob: *mut dpiLob,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_getIsResourceOpen(
        lob: *mut dpiLob,
        isOpen: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_getSize(lob: *mut dpiLob, size: *mut u64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_getType(lob: *mut dpiLob, type_: *mut dpiOracleTypeNum) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_openResource(lob: *mut dpiLob) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_readBytes(
        lob: *mut dpiLob,
        offset: u64,
        amount: u64,
        value: *mut ::std::os::raw::c_char,
        valueLength: *mut u64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_release(lob: *mut dpiLob) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_setDirectoryAndFileName(
        lob: *mut dpiLob,
        directoryAlias: *const ::std::os::raw::c_char,
        directoryAliasLength: u32,
        fileName: *const ::std::os::raw::c_char,
        fileNameLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_setFromBytes(
        lob: *mut dpiLob,
        value: *const ::std::os::raw::c_char,
        valueLength: u64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_trim(lob: *mut dpiLob, newSize: u64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiLob_writeBytes(
        lob: *mut dpiLob,
        offset: u64,
        value: *const ::std::os::raw::c_char,
        valueLength: u64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_addRef(props: *mut dpiMsgProps) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getNumAttempts(
        props: *mut dpiMsgProps,
        value: *mut i32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getCorrelation(
        props: *mut dpiMsgProps,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getDelay(props: *mut dpiMsgProps, value: *mut i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getDeliveryMode(
        props: *mut dpiMsgProps,
        value: *mut dpiMessageDeliveryMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getEnqTime(
        props: *mut dpiMsgProps,
        value: *mut dpiTimestamp,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getExceptionQ(
        props: *mut dpiMsgProps,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getExpiration(
        props: *mut dpiMsgProps,
        value: *mut i32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getMsgId(
        props: *mut dpiMsgProps,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getOriginalMsgId(
        props: *mut dpiMsgProps,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getPayload(
        props: *mut dpiMsgProps,
        obj: *mut *mut dpiObject,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getPayloadJson(
        props: *mut dpiMsgProps,
        json: *mut *mut dpiJson,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getPriority(
        props: *mut dpiMsgProps,
        value: *mut i32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_getState(
        props: *mut dpiMsgProps,
        value: *mut dpiMessageState,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_release(props: *mut dpiMsgProps) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setCorrelation(
        props: *mut dpiMsgProps,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setDelay(props: *mut dpiMsgProps, value: i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setExceptionQ(
        props: *mut dpiMsgProps,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setExpiration(props: *mut dpiMsgProps, value: i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setOriginalMsgId(
        props: *mut dpiMsgProps,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setPayloadBytes(
        props: *mut dpiMsgProps,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setPayloadJson(
        props: *mut dpiMsgProps,
        json: *mut dpiJson,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setPayloadObject(
        props: *mut dpiMsgProps,
        obj: *mut dpiObject,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setPriority(props: *mut dpiMsgProps, value: i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiMsgProps_setRecipients(
        props: *mut dpiMsgProps,
        recipients: *mut dpiMsgRecipient,
        numRecipients: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_addRef(obj: *mut dpiObject) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_appendElement(
        obj: *mut dpiObject,
        nativeTypeNum: dpiNativeTypeNum,
        value: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_copy(
        obj: *mut dpiObject,
        copiedObj: *mut *mut dpiObject,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_deleteElementByIndex(obj: *mut dpiObject, index: i32)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getAttributeValue(
        obj: *mut dpiObject,
        attr: *mut dpiObjectAttr,
        nativeTypeNum: dpiNativeTypeNum,
        value: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getElementExistsByIndex(
        obj: *mut dpiObject,
        index: i32,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getElementValueByIndex(
        obj: *mut dpiObject,
        index: i32,
        nativeTypeNum: dpiNativeTypeNum,
        value: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getFirstIndex(
        obj: *mut dpiObject,
        index: *mut i32,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getLastIndex(
        obj: *mut dpiObject,
        index: *mut i32,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getNextIndex(
        obj: *mut dpiObject,
        index: i32,
        nextIndex: *mut i32,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getPrevIndex(
        obj: *mut dpiObject,
        index: i32,
        prevIndex: *mut i32,
        exists: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_getSize(obj: *mut dpiObject, size: *mut i32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_release(obj: *mut dpiObject) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_setAttributeValue(
        obj: *mut dpiObject,
        attr: *mut dpiObjectAttr,
        nativeTypeNum: dpiNativeTypeNum,
        value: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_setElementValueByIndex(
        obj: *mut dpiObject,
        index: i32,
        nativeTypeNum: dpiNativeTypeNum,
        value: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObject_trim(obj: *mut dpiObject, numToTrim: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectAttr_addRef(attr: *mut dpiObjectAttr) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectAttr_getInfo(
        attr: *mut dpiObjectAttr,
        info: *mut dpiObjectAttrInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectAttr_release(attr: *mut dpiObjectAttr) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectType_addRef(objType: *mut dpiObjectType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectType_createObject(
        objType: *mut dpiObjectType,
        obj: *mut *mut dpiObject,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectType_getAttributes(
        objType: *mut dpiObjectType,
        numAttributes: u16,
        attributes: *mut *mut dpiObjectAttr,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectType_getInfo(
        objType: *mut dpiObjectType,
        info: *mut dpiObjectTypeInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiObjectType_release(objType: *mut dpiObjectType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_acquireConnection(
        pool: *mut dpiPool,
        userName: *const ::std::os::raw::c_char,
        userNameLength: u32,
        password: *const ::std::os::raw::c_char,
        passwordLength: u32,
        createParams: *mut dpiConnCreateParams,
        conn: *mut *mut dpiConn,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_addRef(pool: *mut dpiPool) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_close(pool: *mut dpiPool, closeMode: dpiPoolCloseMode) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_create(
        context: *const dpiContext,
        userName: *const ::std::os::raw::c_char,
        userNameLength: u32,
        password: *const ::std::os::raw::c_char,
        passwordLength: u32,
        connectString: *const ::std::os::raw::c_char,
        connectStringLength: u32,
        commonParams: *const dpiCommonCreateParams,
        createParams: *mut dpiPoolCreateParams,
        pool: *mut *mut dpiPool,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getBusyCount(pool: *mut dpiPool, value: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getEncodingInfo(
        pool: *mut dpiPool,
        info: *mut dpiEncodingInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getGetMode(
        pool: *mut dpiPool,
        value: *mut dpiPoolGetMode,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getMaxLifetimeSession(
        pool: *mut dpiPool,
        value: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getMaxSessionsPerShard(
        pool: *mut dpiPool,
        value: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getOpenCount(pool: *mut dpiPool, value: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getSodaMetadataCache(
        pool: *mut dpiPool,
        enabled: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getStmtCacheSize(
        pool: *mut dpiPool,
        cacheSize: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getTimeout(pool: *mut dpiPool, value: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getWaitTimeout(pool: *mut dpiPool, value: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_getPingInterval(
        pool: *mut dpiPool,
        value: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_release(pool: *mut dpiPool) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setAccessToken(
        pool: *mut dpiPool,
        params: *mut dpiAccessToken,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setGetMode(pool: *mut dpiPool, value: dpiPoolGetMode) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setMaxLifetimeSession(pool: *mut dpiPool, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setMaxSessionsPerShard(pool: *mut dpiPool, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setSodaMetadataCache(
        pool: *mut dpiPool,
        enabled: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setStmtCacheSize(pool: *mut dpiPool, cacheSize: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setTimeout(pool: *mut dpiPool, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setWaitTimeout(pool: *mut dpiPool, value: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_setPingInterval(
        pool: *mut dpiPool,
        value: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_addRef(queue: *mut dpiQueue) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_deqMany(
        queue: *mut dpiQueue,
        numProps: *mut u32,
        props: *mut *mut dpiMsgProps,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_deqOne(
        queue: *mut dpiQueue,
        props: *mut *mut dpiMsgProps,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_enqMany(
        queue: *mut dpiQueue,
        numProps: u32,
        props: *mut *mut dpiMsgProps,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_enqOne(queue: *mut dpiQueue, props: *mut dpiMsgProps) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_getDeqOptions(
        queue: *mut dpiQueue,
        options: *mut *mut dpiDeqOptions,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_getEnqOptions(
        queue: *mut dpiQueue,
        options: *mut *mut dpiEnqOptions,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiQueue_release(queue: *mut dpiQueue) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiPool_reconfigure(
        pool: *mut dpiPool,
        minSessions: u32,
        maxSessions: u32,
        sessionIncrement: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_addRef(coll: *mut dpiSodaColl) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_createIndex(
        coll: *mut dpiSodaColl,
        indexSpec: *const ::std::os::raw::c_char,
        indexSpecLength: u32,
        flags: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_drop(
        coll: *mut dpiSodaColl,
        flags: u32,
        isDropped: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_dropIndex(
        coll: *mut dpiSodaColl,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        flags: u32,
        isDropped: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_find(
        coll: *mut dpiSodaColl,
        options: *const dpiSodaOperOptions,
        flags: u32,
        cursor: *mut *mut dpiSodaDocCursor,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_findOne(
        coll: *mut dpiSodaColl,
        options: *const dpiSodaOperOptions,
        flags: u32,
        doc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_getDataGuide(
        coll: *mut dpiSodaColl,
        flags: u32,
        doc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_getDocCount(
        coll: *mut dpiSodaColl,
        options: *const dpiSodaOperOptions,
        flags: u32,
        count: *mut u64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_getMetadata(
        coll: *mut dpiSodaColl,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_getName(
        coll: *mut dpiSodaColl,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_insertMany(
        coll: *mut dpiSodaColl,
        numDocs: u32,
        docs: *mut *mut dpiSodaDoc,
        flags: u32,
        insertedDocs: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_insertManyWithOptions(
        coll: *mut dpiSodaColl,
        numDocs: u32,
        docs: *mut *mut dpiSodaDoc,
        options: *mut dpiSodaOperOptions,
        flags: u32,
        insertedDocs: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_insertOne(
        coll: *mut dpiSodaColl,
        doc: *mut dpiSodaDoc,
        flags: u32,
        insertedDoc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_insertOneWithOptions(
        coll: *mut dpiSodaColl,
        doc: *mut dpiSodaDoc,
        options: *mut dpiSodaOperOptions,
        flags: u32,
        insertedDoc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_release(coll: *mut dpiSodaColl) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_remove(
        coll: *mut dpiSodaColl,
        options: *const dpiSodaOperOptions,
        flags: u32,
        count: *mut u64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_replaceOne(
        coll: *mut dpiSodaColl,
        options: *const dpiSodaOperOptions,
        doc: *mut dpiSodaDoc,
        flags: u32,
        replaced: *mut ::std::os::raw::c_int,
        replacedDoc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_save(
        coll: *mut dpiSodaColl,
        doc: *mut dpiSodaDoc,
        flags: u32,
        savedDoc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_saveWithOptions(
        coll: *mut dpiSodaColl,
        doc: *mut dpiSodaDoc,
        options: *mut dpiSodaOperOptions,
        flags: u32,
        savedDoc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaColl_truncate(coll: *mut dpiSodaColl) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaCollCursor_addRef(cursor: *mut dpiSodaCollCursor) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaCollCursor_close(cursor: *mut dpiSodaCollCursor) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaCollCursor_getNext(
        cursor: *mut dpiSodaCollCursor,
        flags: u32,
        coll: *mut *mut dpiSodaColl,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaCollCursor_release(cursor: *mut dpiSodaCollCursor) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_addRef(db: *mut dpiSodaDb) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_createCollection(
        db: *mut dpiSodaDb,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        metadata: *const ::std::os::raw::c_char,
        metadataLength: u32,
        flags: u32,
        coll: *mut *mut dpiSodaColl,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_createDocument(
        db: *mut dpiSodaDb,
        key: *const ::std::os::raw::c_char,
        keyLength: u32,
        content: *const ::std::os::raw::c_char,
        contentLength: u32,
        mediaType: *const ::std::os::raw::c_char,
        mediaTypeLength: u32,
        flags: u32,
        doc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_freeCollectionNames(
        db: *mut dpiSodaDb,
        names: *mut dpiSodaCollNames,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_getCollections(
        db: *mut dpiSodaDb,
        startName: *const ::std::os::raw::c_char,
        startNameLength: u32,
        flags: u32,
        cursor: *mut *mut dpiSodaCollCursor,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_getCollectionNames(
        db: *mut dpiSodaDb,
        startName: *const ::std::os::raw::c_char,
        startNameLength: u32,
        limit: u32,
        flags: u32,
        names: *mut dpiSodaCollNames,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_openCollection(
        db: *mut dpiSodaDb,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        flags: u32,
        coll: *mut *mut dpiSodaColl,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDb_release(db: *mut dpiSodaDb) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_addRef(cursor: *mut dpiSodaDoc) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getContent(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
        encoding: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getCreatedOn(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getKey(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getLastModified(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getMediaType(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_getVersion(
        doc: *mut dpiSodaDoc,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDoc_release(doc: *mut dpiSodaDoc) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDocCursor_addRef(cursor: *mut dpiSodaDocCursor) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDocCursor_close(cursor: *mut dpiSodaDocCursor) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDocCursor_getNext(
        cursor: *mut dpiSodaDocCursor,
        flags: u32,
        doc: *mut *mut dpiSodaDoc,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSodaDocCursor_release(cursor: *mut dpiSodaDocCursor) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_addRef(stmt: *mut dpiStmt) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_bindByName(
        stmt: *mut dpiStmt,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        var: *mut dpiVar,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_bindByPos(
        stmt: *mut dpiStmt,
        pos: u32,
        var: *mut dpiVar,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_bindValueByName(
        stmt: *mut dpiStmt,
        name: *const ::std::os::raw::c_char,
        nameLength: u32,
        nativeTypeNum: dpiNativeTypeNum,
        data: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_bindValueByPos(
        stmt: *mut dpiStmt,
        pos: u32,
        nativeTypeNum: dpiNativeTypeNum,
        data: *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_close(
        stmt: *mut dpiStmt,
        tag: *const ::std::os::raw::c_char,
        tagLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_define(stmt: *mut dpiStmt, pos: u32, var: *mut dpiVar) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_defineValue(
        stmt: *mut dpiStmt,
        pos: u32,
        oracleTypeNum: dpiOracleTypeNum,
        nativeTypeNum: dpiNativeTypeNum,
        size: u32,
        sizeIsBytes: ::std::os::raw::c_int,
        objType: *mut dpiObjectType,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_execute(
        stmt: *mut dpiStmt,
        mode: dpiExecMode,
        numQueryColumns: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_executeMany(
        stmt: *mut dpiStmt,
        mode: dpiExecMode,
        numIters: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_fetch(
        stmt: *mut dpiStmt,
        found: *mut ::std::os::raw::c_int,
        bufferRowIndex: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_fetchRows(
        stmt: *mut dpiStmt,
        maxRows: u32,
        bufferRowIndex: *mut u32,
        numRowsFetched: *mut u32,
        moreRows: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getBatchErrorCount(stmt: *mut dpiStmt, count: *mut u32)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getBatchErrors(
        stmt: *mut dpiStmt,
        numErrors: u32,
        errors: *mut dpiErrorInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getBindCount(stmt: *mut dpiStmt, count: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getBindNames(
        stmt: *mut dpiStmt,
        numBindNames: *mut u32,
        bindNames: *mut *const ::std::os::raw::c_char,
        bindNameLengths: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getFetchArraySize(
        stmt: *mut dpiStmt,
        arraySize: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getImplicitResult(
        stmt: *mut dpiStmt,
        implicitResult: *mut *mut dpiStmt,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getInfo(stmt: *mut dpiStmt, info: *mut dpiStmtInfo) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getLastRowid(
        stmt: *mut dpiStmt,
        rowid: *mut *mut dpiRowid,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getNumQueryColumns(
        stmt: *mut dpiStmt,
        numQueryColumns: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getOciAttr(
        stmt: *mut dpiStmt,
        attribute: u32,
        value: *mut dpiDataBuffer,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getPrefetchRows(stmt: *mut dpiStmt, numRows: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getQueryInfo(
        stmt: *mut dpiStmt,
        pos: u32,
        info: *mut dpiQueryInfo,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getQueryValue(
        stmt: *mut dpiStmt,
        pos: u32,
        nativeTypeNum: *mut dpiNativeTypeNum,
        data: *mut *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getRowCount(stmt: *mut dpiStmt, count: *mut u64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getRowCounts(
        stmt: *mut dpiStmt,
        numRowCounts: *mut u32,
        rowCounts: *mut *mut u64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_getSubscrQueryId(stmt: *mut dpiStmt, queryId: *mut u64)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_release(stmt: *mut dpiStmt) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_scroll(
        stmt: *mut dpiStmt,
        mode: dpiFetchMode,
        offset: i32,
        rowCountOffset: i32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_setFetchArraySize(stmt: *mut dpiStmt, arraySize: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_setOciAttr(
        stmt: *mut dpiStmt,
        attribute: u32,
        value: *mut ::std::os::raw::c_void,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_setPrefetchRows(stmt: *mut dpiStmt, numRows: u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiStmt_deleteFromCache(stmt: *mut dpiStmt) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiRowid_addRef(rowid: *mut dpiRowid) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiRowid_getStringValue(
        rowid: *mut dpiRowid,
        value: *mut *const ::std::os::raw::c_char,
        valueLength: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiRowid_release(subscr: *mut dpiRowid) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSubscr_addRef(subscr: *mut dpiSubscr) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSubscr_prepareStmt(
        subscr: *mut dpiSubscr,
        sql: *const ::std::os::raw::c_char,
        sqlLength: u32,
        stmt: *mut *mut dpiStmt,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiSubscr_release(subscr: *mut dpiSubscr) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_addRef(var: *mut dpiVar) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_copyData(
        var: *mut dpiVar,
        pos: u32,
        sourceVar: *mut dpiVar,
        sourcePos: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_getNumElementsInArray(
        var: *mut dpiVar,
        numElements: *mut u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_getReturnedData(
        var: *mut dpiVar,
        pos: u32,
        numElements: *mut u32,
        data: *mut *mut dpiData,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_getSizeInBytes(var: *mut dpiVar, sizeInBytes: *mut u32) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_release(var: *mut dpiVar) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromBytes(
        var: *mut dpiVar,
        pos: u32,
        value: *const ::std::os::raw::c_char,
        valueLength: u32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromJson(
        var: *mut dpiVar,
        pos: u32,
        json: *mut dpiJson,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromLob(var: *mut dpiVar, pos: u32, lob: *mut dpiLob)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromObject(
        var: *mut dpiVar,
        pos: u32,
        obj: *mut dpiObject,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromRowid(
        var: *mut dpiVar,
        pos: u32,
        rowid: *mut dpiRowid,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setFromStmt(
        var: *mut dpiVar,
        pos: u32,
        stmt: *mut dpiStmt,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn dpiVar_setNumElementsInArray(
        var: *mut dpiVar,
        numElements: u32,
    ) -> ::std::os::raw::c_int;
}