//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (383)
//--------------------------------------------------------------------------------
pub const SQLITE_VERSION_NUMBER = @as(u32, 3029000);
pub const SQLITE_OK = @as(u32, 0);
pub const SQLITE_ERROR = @as(u32, 1);
pub const SQLITE_INTERNAL = @as(u32, 2);
pub const SQLITE_PERM = @as(u32, 3);
pub const SQLITE_ABORT = @as(u32, 4);
pub const SQLITE_BUSY = @as(u32, 5);
pub const SQLITE_LOCKED = @as(u32, 6);
pub const SQLITE_NOMEM = @as(u32, 7);
pub const SQLITE_READONLY = @as(u32, 8);
pub const SQLITE_INTERRUPT = @as(u32, 9);
pub const SQLITE_IOERR = @as(u32, 10);
pub const SQLITE_CORRUPT = @as(u32, 11);
pub const SQLITE_NOTFOUND = @as(u32, 12);
pub const SQLITE_FULL = @as(u32, 13);
pub const SQLITE_CANTOPEN = @as(u32, 14);
pub const SQLITE_PROTOCOL = @as(u32, 15);
pub const SQLITE_EMPTY = @as(u32, 16);
pub const SQLITE_SCHEMA = @as(u32, 17);
pub const SQLITE_TOOBIG = @as(u32, 18);
pub const SQLITE_CONSTRAINT = @as(u32, 19);
pub const SQLITE_MISMATCH = @as(u32, 20);
pub const SQLITE_MISUSE = @as(u32, 21);
pub const SQLITE_NOLFS = @as(u32, 22);
pub const SQLITE_AUTH = @as(u32, 23);
pub const SQLITE_FORMAT = @as(u32, 24);
pub const SQLITE_RANGE = @as(u32, 25);
pub const SQLITE_NOTADB = @as(u32, 26);
pub const SQLITE_NOTICE = @as(u32, 27);
pub const SQLITE_WARNING = @as(u32, 28);
pub const SQLITE_ROW = @as(u32, 100);
pub const SQLITE_DONE = @as(u32, 101);
pub const SQLITE_OPEN_READONLY = @as(u32, 1);
pub const SQLITE_OPEN_READWRITE = @as(u32, 2);
pub const SQLITE_OPEN_CREATE = @as(u32, 4);
pub const SQLITE_OPEN_DELETEONCLOSE = @as(u32, 8);
pub const SQLITE_OPEN_EXCLUSIVE = @as(u32, 16);
pub const SQLITE_OPEN_AUTOPROXY = @as(u32, 32);
pub const SQLITE_OPEN_URI = @as(u32, 64);
pub const SQLITE_OPEN_MEMORY = @as(u32, 128);
pub const SQLITE_OPEN_MAIN_DB = @as(u32, 256);
pub const SQLITE_OPEN_TEMP_DB = @as(u32, 512);
pub const SQLITE_OPEN_TRANSIENT_DB = @as(u32, 1024);
pub const SQLITE_OPEN_MAIN_JOURNAL = @as(u32, 2048);
pub const SQLITE_OPEN_TEMP_JOURNAL = @as(u32, 4096);
pub const SQLITE_OPEN_SUBJOURNAL = @as(u32, 8192);
pub const SQLITE_OPEN_SUPER_JOURNAL = @as(u32, 16384);
pub const SQLITE_OPEN_NOMUTEX = @as(u32, 32768);
pub const SQLITE_OPEN_FULLMUTEX = @as(u32, 65536);
pub const SQLITE_OPEN_SHAREDCACHE = @as(u32, 131072);
pub const SQLITE_OPEN_PRIVATECACHE = @as(u32, 262144);
pub const SQLITE_OPEN_WAL = @as(u32, 524288);
pub const SQLITE_OPEN_NOFOLLOW = @as(u32, 16777216);
pub const SQLITE_OPEN_MASTER_JOURNAL = @as(u32, 16384);
pub const SQLITE_IOCAP_ATOMIC = @as(u32, 1);
pub const SQLITE_IOCAP_ATOMIC512 = @as(u32, 2);
pub const SQLITE_IOCAP_ATOMIC1K = @as(u32, 4);
pub const SQLITE_IOCAP_ATOMIC2K = @as(u32, 8);
pub const SQLITE_IOCAP_ATOMIC4K = @as(u32, 16);
pub const SQLITE_IOCAP_ATOMIC8K = @as(u32, 32);
pub const SQLITE_IOCAP_ATOMIC16K = @as(u32, 64);
pub const SQLITE_IOCAP_ATOMIC32K = @as(u32, 128);
pub const SQLITE_IOCAP_ATOMIC64K = @as(u32, 256);
pub const SQLITE_IOCAP_SAFE_APPEND = @as(u32, 512);
pub const SQLITE_IOCAP_SEQUENTIAL = @as(u32, 1024);
pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN = @as(u32, 2048);
pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE = @as(u32, 4096);
pub const SQLITE_IOCAP_IMMUTABLE = @as(u32, 8192);
pub const SQLITE_IOCAP_BATCH_ATOMIC = @as(u32, 16384);
pub const SQLITE_LOCK_NONE = @as(u32, 0);
pub const SQLITE_LOCK_SHARED = @as(u32, 1);
pub const SQLITE_LOCK_RESERVED = @as(u32, 2);
pub const SQLITE_LOCK_PENDING = @as(u32, 3);
pub const SQLITE_LOCK_EXCLUSIVE = @as(u32, 4);
pub const SQLITE_SYNC_NORMAL = @as(u32, 2);
pub const SQLITE_SYNC_FULL = @as(u32, 3);
pub const SQLITE_SYNC_DATAONLY = @as(u32, 16);
pub const SQLITE_FCNTL_LOCKSTATE = @as(u32, 1);
pub const SQLITE_FCNTL_GET_LOCKPROXYFILE = @as(u32, 2);
pub const SQLITE_FCNTL_SET_LOCKPROXYFILE = @as(u32, 3);
pub const SQLITE_FCNTL_LAST_ERRNO = @as(u32, 4);
pub const SQLITE_FCNTL_SIZE_HINT = @as(u32, 5);
pub const SQLITE_FCNTL_CHUNK_SIZE = @as(u32, 6);
pub const SQLITE_FCNTL_FILE_POINTER = @as(u32, 7);
pub const SQLITE_FCNTL_SYNC_OMITTED = @as(u32, 8);
pub const SQLITE_FCNTL_WIN32_AV_RETRY = @as(u32, 9);
pub const SQLITE_FCNTL_PERSIST_WAL = @as(u32, 10);
pub const SQLITE_FCNTL_OVERWRITE = @as(u32, 11);
pub const SQLITE_FCNTL_VFSNAME = @as(u32, 12);
pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE = @as(u32, 13);
pub const SQLITE_FCNTL_PRAGMA = @as(u32, 14);
pub const SQLITE_FCNTL_BUSYHANDLER = @as(u32, 15);
pub const SQLITE_FCNTL_TEMPFILENAME = @as(u32, 16);
pub const SQLITE_FCNTL_MMAP_SIZE = @as(u32, 18);
pub const SQLITE_FCNTL_TRACE = @as(u32, 19);
pub const SQLITE_FCNTL_HAS_MOVED = @as(u32, 20);
pub const SQLITE_FCNTL_SYNC = @as(u32, 21);
pub const SQLITE_FCNTL_COMMIT_PHASETWO = @as(u32, 22);
pub const SQLITE_FCNTL_WIN32_SET_HANDLE = @as(u32, 23);
pub const SQLITE_FCNTL_WAL_BLOCK = @as(u32, 24);
pub const SQLITE_FCNTL_ZIPVFS = @as(u32, 25);
pub const SQLITE_FCNTL_RBU = @as(u32, 26);
pub const SQLITE_FCNTL_VFS_POINTER = @as(u32, 27);
pub const SQLITE_FCNTL_JOURNAL_POINTER = @as(u32, 28);
pub const SQLITE_FCNTL_WIN32_GET_HANDLE = @as(u32, 29);
pub const SQLITE_FCNTL_PDB = @as(u32, 30);
pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE = @as(u32, 31);
pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE = @as(u32, 32);
pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE = @as(u32, 33);
pub const SQLITE_FCNTL_LOCK_TIMEOUT = @as(u32, 34);
pub const SQLITE_FCNTL_DATA_VERSION = @as(u32, 35);
pub const SQLITE_FCNTL_SIZE_LIMIT = @as(u32, 36);
pub const SQLITE_FCNTL_CKPT_DONE = @as(u32, 37);
pub const SQLITE_FCNTL_RESERVE_BYTES = @as(u32, 38);
pub const SQLITE_FCNTL_CKPT_START = @as(u32, 39);
pub const SQLITE_GET_LOCKPROXYFILE = @as(u32, 2);
pub const SQLITE_SET_LOCKPROXYFILE = @as(u32, 3);
pub const SQLITE_LAST_ERRNO = @as(u32, 4);
pub const SQLITE_ACCESS_EXISTS = @as(u32, 0);
pub const SQLITE_ACCESS_READWRITE = @as(u32, 1);
pub const SQLITE_ACCESS_READ = @as(u32, 2);
pub const SQLITE_SHM_UNLOCK = @as(u32, 1);
pub const SQLITE_SHM_LOCK = @as(u32, 2);
pub const SQLITE_SHM_SHARED = @as(u32, 4);
pub const SQLITE_SHM_EXCLUSIVE = @as(u32, 8);
pub const SQLITE_SHM_NLOCK = @as(u32, 8);
pub const SQLITE_CONFIG_SINGLETHREAD = @as(u32, 1);
pub const SQLITE_CONFIG_MULTITHREAD = @as(u32, 2);
pub const SQLITE_CONFIG_SERIALIZED = @as(u32, 3);
pub const SQLITE_CONFIG_MALLOC = @as(u32, 4);
pub const SQLITE_CONFIG_GETMALLOC = @as(u32, 5);
pub const SQLITE_CONFIG_SCRATCH = @as(u32, 6);
pub const SQLITE_CONFIG_PAGECACHE = @as(u32, 7);
pub const SQLITE_CONFIG_HEAP = @as(u32, 8);
pub const SQLITE_CONFIG_MEMSTATUS = @as(u32, 9);
pub const SQLITE_CONFIG_MUTEX = @as(u32, 10);
pub const SQLITE_CONFIG_GETMUTEX = @as(u32, 11);
pub const SQLITE_CONFIG_LOOKASIDE = @as(u32, 13);
pub const SQLITE_CONFIG_PCACHE = @as(u32, 14);
pub const SQLITE_CONFIG_GETPCACHE = @as(u32, 15);
pub const SQLITE_CONFIG_LOG = @as(u32, 16);
pub const SQLITE_CONFIG_URI = @as(u32, 17);
pub const SQLITE_CONFIG_PCACHE2 = @as(u32, 18);
pub const SQLITE_CONFIG_GETPCACHE2 = @as(u32, 19);
pub const SQLITE_CONFIG_COVERING_INDEX_SCAN = @as(u32, 20);
pub const SQLITE_CONFIG_SQLLOG = @as(u32, 21);
pub const SQLITE_CONFIG_MMAP_SIZE = @as(u32, 22);
pub const SQLITE_CONFIG_WIN32_HEAPSIZE = @as(u32, 23);
pub const SQLITE_CONFIG_PCACHE_HDRSZ = @as(u32, 24);
pub const SQLITE_CONFIG_PMASZ = @as(u32, 25);
pub const SQLITE_CONFIG_STMTJRNL_SPILL = @as(u32, 26);
pub const SQLITE_CONFIG_SMALL_MALLOC = @as(u32, 27);
pub const SQLITE_CONFIG_SORTERREF_SIZE = @as(u32, 28);
pub const SQLITE_CONFIG_MEMDB_MAXSIZE = @as(u32, 29);
pub const SQLITE_DBCONFIG_MAINDBNAME = @as(u32, 1000);
pub const SQLITE_DBCONFIG_LOOKASIDE = @as(u32, 1001);
pub const SQLITE_DBCONFIG_ENABLE_FKEY = @as(u32, 1002);
pub const SQLITE_DBCONFIG_ENABLE_TRIGGER = @as(u32, 1003);
pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER = @as(u32, 1004);
pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION = @as(u32, 1005);
pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE = @as(u32, 1006);
pub const SQLITE_DBCONFIG_ENABLE_QPSG = @as(u32, 1007);
pub const SQLITE_DBCONFIG_TRIGGER_EQP = @as(u32, 1008);
pub const SQLITE_DBCONFIG_RESET_DATABASE = @as(u32, 1009);
pub const SQLITE_DBCONFIG_DEFENSIVE = @as(u32, 1010);
pub const SQLITE_DBCONFIG_WRITABLE_SCHEMA = @as(u32, 1011);
pub const SQLITE_DBCONFIG_LEGACY_ALTER_TABLE = @as(u32, 1012);
pub const SQLITE_DBCONFIG_DQS_DML = @as(u32, 1013);
pub const SQLITE_DBCONFIG_DQS_DDL = @as(u32, 1014);
pub const SQLITE_DBCONFIG_ENABLE_VIEW = @as(u32, 1015);
pub const SQLITE_DBCONFIG_LEGACY_FILE_FORMAT = @as(u32, 1016);
pub const SQLITE_DBCONFIG_TRUSTED_SCHEMA = @as(u32, 1017);
pub const SQLITE_DBCONFIG_MAX = @as(u32, 1017);
pub const SQLITE_DENY = @as(u32, 1);
pub const SQLITE_IGNORE = @as(u32, 2);
pub const SQLITE_CREATE_INDEX = @as(u32, 1);
pub const SQLITE_CREATE_TABLE = @as(u32, 2);
pub const SQLITE_CREATE_TEMP_INDEX = @as(u32, 3);
pub const SQLITE_CREATE_TEMP_TABLE = @as(u32, 4);
pub const SQLITE_CREATE_TEMP_TRIGGER = @as(u32, 5);
pub const SQLITE_CREATE_TEMP_VIEW = @as(u32, 6);
pub const SQLITE_CREATE_TRIGGER = @as(u32, 7);
pub const SQLITE_CREATE_VIEW = @as(u32, 8);
pub const SQLITE_DELETE = @as(u32, 9);
pub const SQLITE_DROP_INDEX = @as(u32, 10);
pub const SQLITE_DROP_TABLE = @as(u32, 11);
pub const SQLITE_DROP_TEMP_INDEX = @as(u32, 12);
pub const SQLITE_DROP_TEMP_TABLE = @as(u32, 13);
pub const SQLITE_DROP_TEMP_TRIGGER = @as(u32, 14);
pub const SQLITE_DROP_TEMP_VIEW = @as(u32, 15);
pub const SQLITE_DROP_TRIGGER = @as(u32, 16);
pub const SQLITE_DROP_VIEW = @as(u32, 17);
pub const SQLITE_INSERT = @as(u32, 18);
pub const SQLITE_PRAGMA = @as(u32, 19);
pub const SQLITE_READ = @as(u32, 20);
pub const SQLITE_SELECT = @as(u32, 21);
pub const SQLITE_TRANSACTION = @as(u32, 22);
pub const SQLITE_UPDATE = @as(u32, 23);
pub const SQLITE_ATTACH = @as(u32, 24);
pub const SQLITE_DETACH = @as(u32, 25);
pub const SQLITE_ALTER_TABLE = @as(u32, 26);
pub const SQLITE_REINDEX = @as(u32, 27);
pub const SQLITE_ANALYZE = @as(u32, 28);
pub const SQLITE_CREATE_VTABLE = @as(u32, 29);
pub const SQLITE_DROP_VTABLE = @as(u32, 30);
pub const SQLITE_FUNCTION = @as(u32, 31);
pub const SQLITE_SAVEPOINT = @as(u32, 32);
pub const SQLITE_COPY = @as(u32, 0);
pub const SQLITE_RECURSIVE = @as(u32, 33);
pub const SQLITE_TRACE_STMT = @as(u32, 1);
pub const SQLITE_TRACE_PROFILE = @as(u32, 2);
pub const SQLITE_TRACE_ROW = @as(u32, 4);
pub const SQLITE_TRACE_CLOSE = @as(u32, 8);
pub const SQLITE_LIMIT_LENGTH = @as(u32, 0);
pub const SQLITE_LIMIT_SQL_LENGTH = @as(u32, 1);
pub const SQLITE_LIMIT_COLUMN = @as(u32, 2);
pub const SQLITE_LIMIT_EXPR_DEPTH = @as(u32, 3);
pub const SQLITE_LIMIT_COMPOUND_SELECT = @as(u32, 4);
pub const SQLITE_LIMIT_VDBE_OP = @as(u32, 5);
pub const SQLITE_LIMIT_FUNCTION_ARG = @as(u32, 6);
pub const SQLITE_LIMIT_ATTACHED = @as(u32, 7);
pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH = @as(u32, 8);
pub const SQLITE_LIMIT_VARIABLE_NUMBER = @as(u32, 9);
pub const SQLITE_LIMIT_TRIGGER_DEPTH = @as(u32, 10);
pub const SQLITE_LIMIT_WORKER_THREADS = @as(u32, 11);
pub const SQLITE_PREPARE_PERSISTENT = @as(u32, 1);
pub const SQLITE_PREPARE_NORMALIZE = @as(u32, 2);
pub const SQLITE_PREPARE_NO_VTAB = @as(u32, 4);
pub const SQLITE_INTEGER = @as(u32, 1);
pub const SQLITE_FLOAT = @as(u32, 2);
pub const SQLITE_BLOB = @as(u32, 4);
pub const SQLITE_NULL = @as(u32, 5);
pub const SQLITE3_TEXT = @as(u32, 3);
pub const SQLITE_UTF8 = @as(u32, 1);
pub const SQLITE_UTF16LE = @as(u32, 2);
pub const SQLITE_UTF16BE = @as(u32, 3);
pub const SQLITE_UTF16 = @as(u32, 4);
pub const SQLITE_ANY = @as(u32, 5);
pub const SQLITE_UTF16_ALIGNED = @as(u32, 8);
pub const SQLITE_DETERMINISTIC = @as(u64, 2048);
pub const SQLITE_DIRECTONLY = @as(u64, 524288);
pub const SQLITE_SUBTYPE = @as(u64, 1048576);
pub const SQLITE_INNOCUOUS = @as(u64, 2097152);
pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE = @as(u32, 1);
pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE = @as(u32, 2);
pub const SQLITE_TXN_NONE = @as(u32, 0);
pub const SQLITE_TXN_READ = @as(u32, 1);
pub const SQLITE_TXN_WRITE = @as(u32, 2);
pub const SQLITE_INDEX_SCAN_UNIQUE = @as(u32, 1);
pub const SQLITE_INDEX_CONSTRAINT_EQ = @as(u32, 2);
pub const SQLITE_INDEX_CONSTRAINT_GT = @as(u32, 4);
pub const SQLITE_INDEX_CONSTRAINT_LE = @as(u32, 8);
pub const SQLITE_INDEX_CONSTRAINT_LT = @as(u32, 16);
pub const SQLITE_INDEX_CONSTRAINT_GE = @as(u32, 32);
pub const SQLITE_INDEX_CONSTRAINT_MATCH = @as(u32, 64);
pub const SQLITE_INDEX_CONSTRAINT_LIKE = @as(u32, 65);
pub const SQLITE_INDEX_CONSTRAINT_GLOB = @as(u32, 66);
pub const SQLITE_INDEX_CONSTRAINT_REGEXP = @as(u32, 67);
pub const SQLITE_INDEX_CONSTRAINT_NE = @as(u32, 68);
pub const SQLITE_INDEX_CONSTRAINT_ISNOT = @as(u32, 69);
pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL = @as(u32, 70);
pub const SQLITE_INDEX_CONSTRAINT_ISNULL = @as(u32, 71);
pub const SQLITE_INDEX_CONSTRAINT_IS = @as(u32, 72);
pub const SQLITE_INDEX_CONSTRAINT_FUNCTION = @as(u32, 150);
pub const SQLITE_MUTEX_FAST = @as(u32, 0);
pub const SQLITE_MUTEX_RECURSIVE = @as(u32, 1);
pub const SQLITE_MUTEX_STATIC_MAIN = @as(u32, 2);
pub const SQLITE_MUTEX_STATIC_MEM = @as(u32, 3);
pub const SQLITE_MUTEX_STATIC_MEM2 = @as(u32, 4);
pub const SQLITE_MUTEX_STATIC_OPEN = @as(u32, 4);
pub const SQLITE_MUTEX_STATIC_PRNG = @as(u32, 5);
pub const SQLITE_MUTEX_STATIC_LRU = @as(u32, 6);
pub const SQLITE_MUTEX_STATIC_LRU2 = @as(u32, 7);
pub const SQLITE_MUTEX_STATIC_PMEM = @as(u32, 7);
pub const SQLITE_MUTEX_STATIC_APP1 = @as(u32, 8);
pub const SQLITE_MUTEX_STATIC_APP2 = @as(u32, 9);
pub const SQLITE_MUTEX_STATIC_APP3 = @as(u32, 10);
pub const SQLITE_MUTEX_STATIC_VFS1 = @as(u32, 11);
pub const SQLITE_MUTEX_STATIC_VFS2 = @as(u32, 12);
pub const SQLITE_MUTEX_STATIC_VFS3 = @as(u32, 13);
pub const SQLITE_MUTEX_STATIC_MASTER = @as(u32, 2);
pub const SQLITE_TESTCTRL_FIRST = @as(u32, 5);
pub const SQLITE_TESTCTRL_PRNG_SAVE = @as(u32, 5);
pub const SQLITE_TESTCTRL_PRNG_RESTORE = @as(u32, 6);
pub const SQLITE_TESTCTRL_PRNG_RESET = @as(u32, 7);
pub const SQLITE_TESTCTRL_BITVEC_TEST = @as(u32, 8);
pub const SQLITE_TESTCTRL_FAULT_INSTALL = @as(u32, 9);
pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS = @as(u32, 10);
pub const SQLITE_TESTCTRL_PENDING_BYTE = @as(u32, 11);
pub const SQLITE_TESTCTRL_ASSERT = @as(u32, 12);
pub const SQLITE_TESTCTRL_ALWAYS = @as(u32, 13);
pub const SQLITE_TESTCTRL_RESERVE = @as(u32, 14);
pub const SQLITE_TESTCTRL_OPTIMIZATIONS = @as(u32, 15);
pub const SQLITE_TESTCTRL_ISKEYWORD = @as(u32, 16);
pub const SQLITE_TESTCTRL_SCRATCHMALLOC = @as(u32, 17);
pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS = @as(u32, 17);
pub const SQLITE_TESTCTRL_LOCALTIME_FAULT = @as(u32, 18);
pub const SQLITE_TESTCTRL_EXPLAIN_STMT = @as(u32, 19);
pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD = @as(u32, 19);
pub const SQLITE_TESTCTRL_NEVER_CORRUPT = @as(u32, 20);
pub const SQLITE_TESTCTRL_VDBE_COVERAGE = @as(u32, 21);
pub const SQLITE_TESTCTRL_BYTEORDER = @as(u32, 22);
pub const SQLITE_TESTCTRL_ISINIT = @as(u32, 23);
pub const SQLITE_TESTCTRL_SORTER_MMAP = @as(u32, 24);
pub const SQLITE_TESTCTRL_IMPOSTER = @as(u32, 25);
pub const SQLITE_TESTCTRL_PARSER_COVERAGE = @as(u32, 26);
pub const SQLITE_TESTCTRL_RESULT_INTREAL = @as(u32, 27);
pub const SQLITE_TESTCTRL_PRNG_SEED = @as(u32, 28);
pub const SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS = @as(u32, 29);
pub const SQLITE_TESTCTRL_SEEK_COUNT = @as(u32, 30);
pub const SQLITE_TESTCTRL_LAST = @as(u32, 30);
pub const SQLITE_STATUS_MEMORY_USED = @as(u32, 0);
pub const SQLITE_STATUS_PAGECACHE_USED = @as(u32, 1);
pub const SQLITE_STATUS_PAGECACHE_OVERFLOW = @as(u32, 2);
pub const SQLITE_STATUS_SCRATCH_USED = @as(u32, 3);
pub const SQLITE_STATUS_SCRATCH_OVERFLOW = @as(u32, 4);
pub const SQLITE_STATUS_MALLOC_SIZE = @as(u32, 5);
pub const SQLITE_STATUS_PARSER_STACK = @as(u32, 6);
pub const SQLITE_STATUS_PAGECACHE_SIZE = @as(u32, 7);
pub const SQLITE_STATUS_SCRATCH_SIZE = @as(u32, 8);
pub const SQLITE_STATUS_MALLOC_COUNT = @as(u32, 9);
pub const SQLITE_DBSTATUS_LOOKASIDE_USED = @as(u32, 0);
pub const SQLITE_DBSTATUS_CACHE_USED = @as(u32, 1);
pub const SQLITE_DBSTATUS_SCHEMA_USED = @as(u32, 2);
pub const SQLITE_DBSTATUS_STMT_USED = @as(u32, 3);
pub const SQLITE_DBSTATUS_LOOKASIDE_HIT = @as(u32, 4);
pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE = @as(u32, 5);
pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL = @as(u32, 6);
pub const SQLITE_DBSTATUS_CACHE_HIT = @as(u32, 7);
pub const SQLITE_DBSTATUS_CACHE_MISS = @as(u32, 8);
pub const SQLITE_DBSTATUS_CACHE_WRITE = @as(u32, 9);
pub const SQLITE_DBSTATUS_DEFERRED_FKS = @as(u32, 10);
pub const SQLITE_DBSTATUS_CACHE_USED_SHARED = @as(u32, 11);
pub const SQLITE_DBSTATUS_CACHE_SPILL = @as(u32, 12);
pub const SQLITE_DBSTATUS_MAX = @as(u32, 12);
pub const SQLITE_STMTSTATUS_FULLSCAN_STEP = @as(u32, 1);
pub const SQLITE_STMTSTATUS_SORT = @as(u32, 2);
pub const SQLITE_STMTSTATUS_AUTOINDEX = @as(u32, 3);
pub const SQLITE_STMTSTATUS_VM_STEP = @as(u32, 4);
pub const SQLITE_STMTSTATUS_REPREPARE = @as(u32, 5);
pub const SQLITE_STMTSTATUS_RUN = @as(u32, 6);
pub const SQLITE_STMTSTATUS_MEMUSED = @as(u32, 99);
pub const SQLITE_CHECKPOINT_PASSIVE = @as(u32, 0);
pub const SQLITE_CHECKPOINT_FULL = @as(u32, 1);
pub const SQLITE_CHECKPOINT_RESTART = @as(u32, 2);
pub const SQLITE_CHECKPOINT_TRUNCATE = @as(u32, 3);
pub const SQLITE_VTAB_CONSTRAINT_SUPPORT = @as(u32, 1);
pub const SQLITE_VTAB_INNOCUOUS = @as(u32, 2);
pub const SQLITE_VTAB_DIRECTONLY = @as(u32, 3);
pub const SQLITE_ROLLBACK = @as(u32, 1);
pub const SQLITE_FAIL = @as(u32, 3);
pub const SQLITE_REPLACE = @as(u32, 5);
pub const SQLITE_SCANSTAT_NLOOP = @as(u32, 0);
pub const SQLITE_SCANSTAT_NVISIT = @as(u32, 1);
pub const SQLITE_SCANSTAT_EST = @as(u32, 2);
pub const SQLITE_SCANSTAT_NAME = @as(u32, 3);
pub const SQLITE_SCANSTAT_EXPLAIN = @as(u32, 4);
pub const SQLITE_SCANSTAT_SELECTID = @as(u32, 5);
pub const SQLITE_SERIALIZE_NOCOPY = @as(u32, 1);
pub const SQLITE_DESERIALIZE_FREEONCLOSE = @as(u32, 1);
pub const SQLITE_DESERIALIZE_RESIZEABLE = @as(u32, 2);
pub const SQLITE_DESERIALIZE_READONLY = @as(u32, 4);
pub const NOT_WITHIN = @as(u32, 0);
pub const PARTLY_WITHIN = @as(u32, 1);
pub const FULLY_WITHIN = @as(u32, 2);
pub const __SQLITESESSION_H_ = @as(u32, 1);
pub const SQLITE_CHANGESETSTART_INVERT = @as(u32, 2);
pub const SQLITE_CHANGESETAPPLY_NOSAVEPOINT = @as(u32, 1);
pub const SQLITE_CHANGESETAPPLY_INVERT = @as(u32, 2);
pub const SQLITE_CHANGESET_DATA = @as(u32, 1);
pub const SQLITE_CHANGESET_NOTFOUND = @as(u32, 2);
pub const SQLITE_CHANGESET_CONFLICT = @as(u32, 3);
pub const SQLITE_CHANGESET_CONSTRAINT = @as(u32, 4);
pub const SQLITE_CHANGESET_FOREIGN_KEY = @as(u32, 5);
pub const SQLITE_CHANGESET_OMIT = @as(u32, 0);
pub const SQLITE_CHANGESET_REPLACE = @as(u32, 1);
pub const SQLITE_CHANGESET_ABORT = @as(u32, 2);
pub const SQLITE_SESSION_CONFIG_STRMSIZE = @as(u32, 1);
pub const FTS5_TOKENIZE_QUERY = @as(u32, 1);
pub const FTS5_TOKENIZE_PREFIX = @as(u32, 2);
pub const FTS5_TOKENIZE_DOCUMENT = @as(u32, 4);
pub const FTS5_TOKENIZE_AUX = @as(u32, 8);
pub const FTS5_TOKEN_COLOCATED = @as(u32, 1);

//--------------------------------------------------------------------------------
// Section: Types (37)
//--------------------------------------------------------------------------------
pub const sqlite3 = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const sqlite3_mutex = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const sqlite3_stmt = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const sqlite3_value = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const sqlite3_context = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const sqlite3_blob = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const sqlite3_str = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const sqlite3_pcache = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const sqlite3_backup = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const Fts5Context = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const Fts5Tokenizer = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const sqlite3_callback = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*anyopaque,
        param1: i32,
        param2: ?*?*i8,
        param3: ?*?*i8,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        param0: ?*anyopaque,
        param1: i32,
        param2: ?*?*i8,
        param3: ?*?*i8,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const sqlite3_file = extern struct {
    pMethods: ?*const sqlite3_io_methods,
};

pub const sqlite3_io_methods = extern struct {
    iVersion: i32,
    xClose: isize,
    xRead: isize,
    xWrite: isize,
    xTruncate: isize,
    xSync: isize,
    xFileSize: isize,
    xLock: isize,
    xUnlock: isize,
    xCheckReservedLock: isize,
    xFileControl: isize,
    xSectorSize: isize,
    xDeviceCharacteristics: isize,
    xShmMap: isize,
    xShmLock: isize,
    xShmBarrier: isize,
    xShmUnmap: isize,
    xFetch: isize,
    xUnfetch: isize,
};

pub const sqlite3_syscall_ptr = switch (@import("builtin").zig_backend) {
    .stage1 => fn () callconv(@import("std").os.windows.WINAPI) void,
    else => *const fn () callconv(@import("std").os.windows.WINAPI) void,
};

pub const sqlite3_vfs = extern struct {
    iVersion: i32,
    szOsFile: i32,
    mxPathname: i32,
    pNext: ?*sqlite3_vfs,
    zName: ?[*:0]const u8,
    pAppData: ?*anyopaque,
    xOpen: isize,
    xDelete: isize,
    xAccess: isize,
    xFullPathname: isize,
    xDlOpen: isize,
    xDlError: isize,
    xDlSym: isize,
    xDlClose: isize,
    xRandomness: isize,
    xSleep: isize,
    xCurrentTime: isize,
    xGetLastError: isize,
    xCurrentTimeInt64: isize,
    xSetSystemCall: isize,
    xGetSystemCall: isize,
    xNextSystemCall: isize,
};

pub const sqlite3_mem_methods = extern struct {
    xMalloc: isize,
    xFree: isize,
    xRealloc: isize,
    xSize: isize,
    xRoundup: isize,
    xInit: isize,
    xShutdown: isize,
    pAppData: ?*anyopaque,
};

pub const sqlite3_destructor_type = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) void,
    else => *const fn (
        param0: ?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) void,
};

pub const sqlite3_module = extern struct {
    iVersion: i32,
    xCreate: isize,
    xConnect: isize,
    xBestIndex: isize,
    xDisconnect: isize,
    xDestroy: isize,
    xOpen: isize,
    xClose: isize,
    xFilter: isize,
    xNext: isize,
    xEof: isize,
    xColumn: isize,
    xRowid: isize,
    xUpdate: isize,
    xBegin: isize,
    xSync: isize,
    xCommit: isize,
    xRollback: isize,
    xFindFunction: isize,
    xRename: isize,
    xSavepoint: isize,
    xRelease: isize,
    xRollbackTo: isize,
    xShadowName: isize,
};

pub const sqlite3_index_info = extern struct {
    pub const sqlite3_index_orderby = extern struct {
        iColumn: i32,
        desc: u8,
    };
    pub const sqlite3_index_constraint_usage = extern struct {
        argvIndex: i32,
        omit: u8,
    };
    pub const sqlite3_index_constraint = extern struct {
        iColumn: i32,
        op: u8,
        usable: u8,
        iTermOffset: i32,
    };
    nConstraint: i32,
    aConstraint: ?*sqlite3_index_constraint,
    nOrderBy: i32,
    aOrderBy: ?*sqlite3_index_orderby,
    aConstraintUsage: ?*sqlite3_index_constraint_usage,
    idxNum: i32,
    idxStr: ?PSTR,
    needToFreeIdxStr: i32,
    orderByConsumed: i32,
    estimatedCost: f64,
    estimatedRows: i64,
    idxFlags: i32,
    colUsed: u64,
};

pub const sqlite3_vtab = extern struct {
    pModule: ?*const sqlite3_module,
    nRef: i32,
    zErrMsg: ?PSTR,
};

pub const sqlite3_vtab_cursor = extern struct {
    pVtab: ?*sqlite3_vtab,
};

pub const sqlite3_mutex_methods = extern struct {
    xMutexInit: isize,
    xMutexEnd: isize,
    xMutexAlloc: ?*?*?*?*?*?*?*?*?*sqlite3_mutex,
    xMutexFree: isize,
    xMutexEnter: isize,
    xMutexTry: isize,
    xMutexLeave: isize,
    xMutexHeld: isize,
    xMutexNotheld: isize,
};

pub const sqlite3_pcache_page = extern struct {
    pBuf: ?*anyopaque,
    pExtra: ?*anyopaque,
};

pub const sqlite3_pcache_methods2 = extern struct {
    iVersion: i32,
    pArg: ?*anyopaque,
    xInit: isize,
    xShutdown: isize,
    xCreate: ?*?*?*?*?*?*?*?*?*sqlite3_pcache,
    xCachesize: isize,
    xPagecount: isize,
    xFetch: ?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_pcache_page,
    xUnpin: isize,
    xRekey: isize,
    xTruncate: isize,
    xDestroy: isize,
    xShrink: isize,
};

pub const sqlite3_pcache_methods = extern struct {
    pArg: ?*anyopaque,
    xInit: isize,
    xShutdown: isize,
    xCreate: ?*?*?*?*?*?*?*?*?*sqlite3_pcache,
    xCachesize: isize,
    xPagecount: isize,
    xFetch: isize,
    xUnpin: isize,
    xRekey: isize,
    xTruncate: isize,
    xDestroy: isize,
};

pub const sqlite3_snapshot = extern struct {
    hidden: [48]u8,
};

pub const sqlite3_rtree_geometry = extern struct {
    pContext: ?*anyopaque,
    nParam: i32,
    aParam: ?*f64,
    pUser: ?*anyopaque,
    xDelUser: isize,
};

pub const sqlite3_rtree_query_info = extern struct {
    pContext: ?*anyopaque,
    nParam: i32,
    aParam: ?*f64,
    pUser: ?*anyopaque,
    xDelUser: isize,
    aCoord: ?*f64,
    anQueue: ?*u32,
    nCoord: i32,
    iLevel: i32,
    mxLevel: i32,
    iRowid: i64,
    rParentScore: f64,
    eParentWithin: i32,
    eWithin: i32,
    rScore: f64,
    apSqlParam: ?*?*sqlite3_value,
};

pub const fts5_extension_function = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        pApi: ?*const Fts5ExtensionApi,
        pFts: ?*Fts5Context,
        pCtx: ?*sqlite3_context,
        nVal: i32,
        apVal: ?*?*sqlite3_value,
    ) callconv(@import("std").os.windows.WINAPI) void,
    else => *const fn (
        pApi: ?*const Fts5ExtensionApi,
        pFts: ?*Fts5Context,
        pCtx: ?*sqlite3_context,
        nVal: i32,
        apVal: ?*?*sqlite3_value,
    ) callconv(@import("std").os.windows.WINAPI) void,
};

pub const Fts5PhraseIter = extern struct {
    a: ?*const u8,
    b: ?*const u8,
};

pub const Fts5ExtensionApi = extern struct {
    iVersion: i32,
    xUserData: isize,
    xColumnCount: isize,
    xRowCount: isize,
    xColumnTotalSize: isize,
    xTokenize: isize,
    xPhraseCount: isize,
    xPhraseSize: isize,
    xInstCount: isize,
    xInst: isize,
    xRowid: isize,
    xColumnText: isize,
    xColumnSize: isize,
    xQueryPhrase: isize,
    xSetAuxdata: isize,
    xGetAuxdata: isize,
    xPhraseFirst: isize,
    xPhraseNext: isize,
    xPhraseFirstColumn: isize,
    xPhraseNextColumn: isize,
};

pub const fts5_tokenizer = extern struct {
    xCreate: isize,
    xDelete: isize,
    xTokenize: isize,
};

pub const fts5_api = extern struct {
    iVersion: i32,
    xCreateTokenizer: isize,
    xFindTokenizer: isize,
    xCreateFunction: isize,
};

pub const sqlite3_loadext_entry = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        db: ?*sqlite3,
        pzErrMsg: ?*?*i8,
        pThunk: ?*const sqlite3_api_routines,
    ) callconv(@import("std").os.windows.WINAPI) i32,
    else => *const fn (
        db: ?*sqlite3,
        pzErrMsg: ?*?*i8,
        pThunk: ?*const sqlite3_api_routines,
    ) callconv(@import("std").os.windows.WINAPI) i32,
};

pub const sqlite3_api_routines = switch (@import("../zig.zig").arch) {
    .X64, .Arm64 => extern struct {
        aggregate_context: isize,
        aggregate_count: isize,
        bind_blob: isize,
        bind_double: isize,
        bind_int: isize,
        bind_int64: isize,
        bind_null: isize,
        bind_parameter_count: isize,
        bind_parameter_index: isize,
        bind_parameter_name: isize,
        bind_text: isize,
        bind_text16: isize,
        bind_value: isize,
        busy_handler: isize,
        busy_timeout: isize,
        changes: isize,
        close: isize,
        collation_needed: isize,
        collation_needed16: isize,
        column_blob: isize,
        column_bytes: isize,
        column_bytes16: isize,
        column_count: isize,
        column_database_name: isize,
        column_database_name16: isize,
        column_decltype: isize,
        column_decltype16: isize,
        column_double: isize,
        column_int: isize,
        column_int64: isize,
        column_name: isize,
        column_name16: isize,
        column_origin_name: isize,
        column_origin_name16: isize,
        column_table_name: isize,
        column_table_name16: isize,
        column_text: isize,
        column_text16: isize,
        column_type: isize,
        column_value: ?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_value,
        commit_hook: isize,
        complete: isize,
        complete16: isize,
        create_collation: isize,
        create_collation16: isize,
        create_function: isize,
        create_function16: isize,
        create_module: isize,
        data_count: isize,
        db_handle: ?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*sqlite3,
        declare_vtab: isize,
        enable_shared_cache: isize,
        errcode: isize,
        errmsg: isize,
        errmsg16: isize,
        exec: isize,
        expired: isize,
        finalize: isize,
        free: isize,
        free_table: isize,
        get_autocommit: isize,
        get_auxdata: isize,
        get_table: isize,
        global_recover: isize,
        interruptx: isize,
        last_insert_rowid: isize,
        libversion: isize,
        libversion_number: isize,
        malloc: isize,
        mprintf: isize,
        open: isize,
        open16: isize,
        prepare: isize,
        prepare16: isize,
        profile: isize,
        progress_handler: isize,
        realloc: isize,
        reset: isize,
        result_blob: isize,
        result_double: isize,
        result_error: isize,
        result_error16: isize,
        result_int: isize,
        result_int64: isize,
        result_null: isize,
        result_text: isize,
        result_text16: isize,
        result_text16be: isize,
        result_text16le: isize,
        result_value: isize,
        rollback_hook: isize,
        set_authorizer: isize,
        set_auxdata: isize,
        xsnprintf: isize,
        step: isize,
        table_column_metadata: isize,
        thread_cleanup: isize,
        total_changes: isize,
        trace: isize,
        transfer_bindings: isize,
        update_hook: isize,
        user_data: isize,
        value_blob: isize,
        value_bytes: isize,
        value_bytes16: isize,
        value_double: isize,
        value_int: isize,
        value_int64: isize,
        value_numeric_type: isize,
        value_text: isize,
        value_text16: isize,
        value_text16be: isize,
        value_text16le: isize,
        value_type: isize,
        vmprintf: isize,
        overload_function: isize,
        prepare_v2: isize,
        prepare16_v2: isize,
        clear_bindings: isize,
        create_module_v2: isize,
        bind_zeroblob: isize,
        blob_bytes: isize,
        blob_close: isize,
        blob_open: isize,
        blob_read: isize,
        blob_write: isize,
        create_collation_v2: isize,
        file_control: isize,
        memory_highwater: isize,
        memory_used: isize,
        mutex_alloc: ?*?*?*?*?*?*?*?*?*sqlite3_mutex,
        mutex_enter: isize,
        mutex_free: isize,
        mutex_leave: isize,
        mutex_try: isize,
        open_v2: isize,
        release_memory: isize,
        result_error_nomem: isize,
        result_error_toobig: isize,
        sleep: isize,
        soft_heap_limit: isize,
        vfs_find: ?*?*?*?*?*?*?*?*?*?*sqlite3_vfs,
        vfs_register: isize,
        vfs_unregister: isize,
        xthreadsafe: isize,
        result_zeroblob: isize,
        result_error_code: isize,
        test_control: isize,
        randomness: isize,
        context_db_handle: ?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*sqlite3,
        extended_result_codes: isize,
        limit: isize,
        next_stmt: ?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_stmt,
        sql: isize,
        status: isize,
        backup_finish: isize,
        backup_init: ?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_backup,
        backup_pagecount: isize,
        backup_remaining: isize,
        backup_step: isize,
        compileoption_get: isize,
        compileoption_used: isize,
        create_function_v2: isize,
        db_config: isize,
        db_mutex: ?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_mutex,
        db_status: isize,
        extended_errcode: isize,
        log: isize,
        soft_heap_limit64: isize,
        sourceid: isize,
        stmt_status: isize,
        strnicmp: isize,
        unlock_notify: isize,
        wal_autocheckpoint: isize,
        wal_checkpoint: isize,
        wal_hook: isize,
        blob_reopen: isize,
        vtab_config: isize,
        vtab_on_conflict: isize,
        close_v2: isize,
        db_filename: isize,
        db_readonly: isize,
        db_release_memory: isize,
        errstr: isize,
        stmt_busy: isize,
        stmt_readonly: isize,
        stricmp: isize,
        uri_boolean: isize,
        uri_int64: isize,
        uri_parameter: isize,
        xvsnprintf: isize,
        wal_checkpoint_v2: isize,
        auto_extension: isize,
        bind_blob64: isize,
        bind_text64: isize,
        cancel_auto_extension: isize,
        load_extension: isize,
        malloc64: isize,
        msize: isize,
        realloc64: isize,
        reset_auto_extension: isize,
        result_blob64: isize,
        result_text64: isize,
        strglob: isize,
        value_dup: ?*?*?*?*?*?*?*?*?*?*sqlite3_value,
        value_free: isize,
        result_zeroblob64: isize,
        bind_zeroblob64: isize,
        value_subtype: isize,
        result_subtype: isize,
        status64: isize,
        strlike: isize,
        db_cacheflush: isize,
        system_errno: isize,
        trace_v2: isize,
        expanded_sql: isize,
        set_last_insert_rowid: isize,
        prepare_v3: isize,
        prepare16_v3: isize,
        bind_pointer: isize,
        result_pointer: isize,
        value_pointer: isize,
        vtab_nochange: isize,
        value_nochange: isize,
        vtab_collation: isize,
        keyword_count: isize,
        keyword_name: isize,
        keyword_check: isize,
        str_new: ?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_str,
        str_finish: isize,
        str_appendf: isize,
        str_vappendf: isize,
        str_append: isize,
        str_appendall: isize,
        str_appendchar: isize,
        str_reset: isize,
        str_errcode: isize,
        str_length: isize,
        str_value: isize,
        create_window_function: isize,
        normalized_sql: isize,
        stmt_isexplain: isize,
        value_frombind: isize,
        drop_modules: isize,
        hard_heap_limit64: isize,
        uri_key: isize,
        filename_database: isize,
        filename_journal: isize,
        filename_wal: isize,
        create_filename: isize,
        free_filename: isize,
        database_file_object: ?*?*?*?*?*?*?*?*?*?*sqlite3_file,
        txn_state: isize,
    },
    .X86 => extern struct {
        aggregate_context: isize,
        aggregate_count: isize,
        bind_blob: isize,
        bind_double: isize,
        bind_int: isize,
        bind_int64: isize,
        bind_null: isize,
        bind_parameter_count: isize,
        bind_parameter_index: isize,
        bind_parameter_name: isize,
        bind_text: isize,
        bind_text16: isize,
        bind_value: isize,
        busy_handler: isize,
        busy_timeout: isize,
        changes: isize,
        close: isize,
        collation_needed: isize,
        collation_needed16: isize,
        column_blob: isize,
        column_bytes: isize,
        column_bytes16: isize,
        column_count: isize,
        column_database_name: isize,
        column_database_name16: isize,
        column_decltype: isize,
        column_decltype16: isize,
        column_double: isize,
        column_int: isize,
        column_int64: isize,
        column_name: isize,
        column_name16: isize,
        column_origin_name: isize,
        column_origin_name16: isize,
        column_table_name: isize,
        column_table_name16: isize,
        column_text: isize,
        column_text16: isize,
        column_type: isize,
        column_value: ?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_value,
        commit_hook: isize,
        complete: isize,
        complete16: isize,
        create_collation: isize,
        create_collation16: isize,
        create_function: isize,
        create_function16: isize,
        create_module: isize,
        data_count: isize,
        db_handle: ?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*sqlite3,
        declare_vtab: isize,
        enable_shared_cache: isize,
        errcode: isize,
        errmsg: isize,
        errmsg16: isize,
        exec: isize,
        expired: isize,
        finalize: isize,
        free: isize,
        free_table: isize,
        get_autocommit: isize,
        get_auxdata: isize,
        get_table: isize,
        global_recover: isize,
        interruptx: isize,
        last_insert_rowid: isize,
        libversion: isize,
        libversion_number: isize,
        malloc: isize,
        mprintf: isize,
        open: isize,
        open16: isize,
        prepare: isize,
        prepare16: isize,
        profile: isize,
        progress_handler: isize,
        realloc: isize,
        reset: isize,
        result_blob: isize,
        result_double: isize,
        result_error: isize,
        result_error16: isize,
        result_int: isize,
        result_int64: isize,
        result_null: isize,
        result_text: isize,
        result_text16: isize,
        result_text16be: isize,
        result_text16le: isize,
        result_value: isize,
        rollback_hook: isize,
        set_authorizer: isize,
        set_auxdata: isize,
        xsnprintf: isize,
        step: isize,
        table_column_metadata: isize,
        thread_cleanup: isize,
        total_changes: isize,
        trace: isize,
        transfer_bindings: isize,
        update_hook: isize,
        user_data: isize,
        value_blob: isize,
        value_bytes: isize,
        value_bytes16: isize,
        value_double: isize,
        value_int: isize,
        value_int64: isize,
        value_numeric_type: isize,
        value_text: isize,
        value_text16: isize,
        value_text16be: isize,
        value_text16le: isize,
        value_type: isize,
        vmprintf: isize,
        overload_function: isize,
        prepare_v2: isize,
        prepare16_v2: isize,
        clear_bindings: isize,
        create_module_v2: isize,
        bind_zeroblob: isize,
        blob_bytes: isize,
        blob_close: isize,
        blob_open: isize,
        blob_read: isize,
        blob_write: isize,
        create_collation_v2: isize,
        file_control: isize,
        memory_highwater: isize,
        memory_used: isize,
        mutex_alloc: ?*?*?*?*?*?*?*?*?*sqlite3_mutex,
        mutex_enter: isize,
        mutex_free: isize,
        mutex_leave: isize,
        mutex_try: isize,
        open_v2: isize,
        release_memory: isize,
        result_error_nomem: isize,
        result_error_toobig: isize,
        sleep: isize,
        soft_heap_limit: isize,
        vfs_find: ?*?*?*?*?*?*?*?*?*?*sqlite3_vfs,
        vfs_register: isize,
        vfs_unregister: isize,
        xthreadsafe: isize,
        result_zeroblob: isize,
        result_error_code: isize,
        test_control: isize,
        randomness: isize,
        context_db_handle: ?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*?*sqlite3,
        extended_result_codes: isize,
        limit: isize,
        next_stmt: ?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_stmt,
        sql: isize,
        status: isize,
        backup_finish: isize,
        backup_init: ?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_backup,
        backup_pagecount: isize,
        backup_remaining: isize,
        backup_step: isize,
        compileoption_get: isize,
        compileoption_used: isize,
        create_function_v2: isize,
        db_config: isize,
        db_mutex: ?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_mutex,
        db_status: isize,
        extended_errcode: isize,
        log: isize,
        soft_heap_limit64: isize,
        sourceid: isize,
        stmt_status: isize,
        strnicmp: isize,
        unlock_notify: isize,
        wal_autocheckpoint: isize,
        wal_checkpoint: isize,
        wal_hook: isize,
        blob_reopen: isize,
        vtab_config: isize,
        vtab_on_conflict: isize,
        close_v2: isize,
        db_filename: isize,
        db_readonly: isize,
        db_release_memory: isize,
        errstr: isize,
        stmt_busy: isize,
        stmt_readonly: isize,
        stricmp: isize,
        uri_boolean: isize,
        uri_int64: isize,
        uri_parameter: isize,
        xvsnprintf: isize,
        wal_checkpoint_v2: isize,
        auto_extension: isize,
        bind_blob64: isize,
        bind_text64: isize,
        cancel_auto_extension: isize,
        load_extension: isize,
        malloc64: isize,
        msize: isize,
        realloc64: isize,
        reset_auto_extension: isize,
        result_blob64: isize,
        result_text64: isize,
        strglob: isize,
        value_dup: ?*?*?*?*?*?*?*?*?*?*sqlite3_value,
        value_free: isize,
        result_zeroblob64: isize,
        bind_zeroblob64: isize,
        value_subtype: isize,
        result_subtype: isize,
        status64: isize,
        strlike: isize,
        db_cacheflush: isize,
        system_errno: isize,
        trace_v2: isize,
        expanded_sql: isize,
        set_last_insert_rowid: isize,
        prepare_v3: isize,
        prepare16_v3: isize,
        bind_pointer: isize,
        result_pointer: isize,
        value_pointer: isize,
        vtab_nochange: isize,
        value_nochange: isize,
        vtab_collation: isize,
        keyword_count: isize,
        keyword_name: isize,
        keyword_check: isize,
        str_new: ?*?*?*?*?*?*?*?*?*?*?*?*sqlite3_str,
        str_finish: isize,
        str_appendf: isize,
        str_vappendf: isize,
        str_append: isize,
        str_appendall: isize,
        str_appendchar: isize,
        str_reset: isize,
        str_errcode: isize,
        str_length: isize,
        str_value: isize,
        create_window_function: isize,
        normalized_sql: isize,
        stmt_isexplain: isize,
        value_frombind: isize,
        drop_modules: isize,
        hard_heap_limit64: isize,
        uri_key: isize,
        filename_database: isize,
        filename_journal: isize,
        filename_wal: isize,
        create_filename: isize,
        free_filename: isize,
        database_file_object: ?*?*?*?*?*?*?*?*?*?*sqlite3_file,
        txn_state: isize,
    },
};

//--------------------------------------------------------------------------------
// Section: Functions (265)
//--------------------------------------------------------------------------------
pub extern "winsqlite3" fn sqlite3_libversion() callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_sourceid() callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_libversion_number() callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_compileoption_used(
    zOptName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_compileoption_get(
    N: i32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_threadsafe() callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_close(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_close_v2(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_exec(
    param0: ?*sqlite3,
    sql: ?[*:0]const u8,
    callback: isize,
    param3: ?*anyopaque,
    errmsg: ?*?*i8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_initialize() callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_shutdown() callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_os_init() callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_os_end() callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_config(
    param0: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_db_config(
    param0: ?*sqlite3,
    op: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_extended_result_codes(
    param0: ?*sqlite3,
    onoff: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_last_insert_rowid(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i64;

pub extern "winsqlite3" fn sqlite3_set_last_insert_rowid(
    param0: ?*sqlite3,
    param1: i64,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_changes(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_total_changes(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_interrupt(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_complete(
    sql: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_complete16(
    sql: ?*const anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_busy_handler(
    param0: ?*sqlite3,
    param1: isize,
    param2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_busy_timeout(
    param0: ?*sqlite3,
    ms: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_get_table(
    db: ?*sqlite3,
    zSql: ?[*:0]const u8,
    pazResult: ?*?*?*i8,
    pnRow: ?*i32,
    pnColumn: ?*i32,
    pzErrmsg: ?*?*i8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_free_table(
    result: ?*?*i8,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_mprintf(
    param0: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_vmprintf(
    param0: ?[*:0]const u8,
    param1: ?*i8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_snprintf(
    param0: i32,
    param1: ?PSTR,
    param2: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_vsnprintf(
    param0: i32,
    param1: ?PSTR,
    param2: ?[*:0]const u8,
    param3: ?*i8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_malloc(
    param0: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_malloc64(
    param0: u64,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_realloc(
    param0: ?*anyopaque,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_realloc64(
    param0: ?*anyopaque,
    param1: u64,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_free(
    param0: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_msize(
    param0: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) u64;

pub extern "winsqlite3" fn sqlite3_memory_used() callconv(@import("std").os.windows.WINAPI) i64;

pub extern "winsqlite3" fn sqlite3_memory_highwater(
    resetFlag: i32,
) callconv(@import("std").os.windows.WINAPI) i64;

pub extern "winsqlite3" fn sqlite3_randomness(
    N: i32,
    P: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_set_authorizer(
    param0: ?*sqlite3,
    xAuth: isize,
    pUserData: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_trace(
    param0: ?*sqlite3,
    xTrace: isize,
    param2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_profile(
    param0: ?*sqlite3,
    xProfile: isize,
    param2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_trace_v2(
    param0: ?*sqlite3,
    uMask: u32,
    xCallback: isize,
    pCtx: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_progress_handler(
    param0: ?*sqlite3,
    param1: i32,
    param2: isize,
    param3: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_open(
    filename: ?[*:0]const u8,
    ppDb: ?*?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_open16(
    filename: ?*const anyopaque,
    ppDb: ?*?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_open_v2(
    filename: ?[*:0]const u8,
    ppDb: ?*?*sqlite3,
    flags: i32,
    zVfs: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_uri_parameter(
    zFilename: ?[*:0]const u8,
    zParam: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_uri_boolean(
    zFile: ?[*:0]const u8,
    zParam: ?[*:0]const u8,
    bDefault: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_uri_int64(
    param0: ?[*:0]const u8,
    param1: ?[*:0]const u8,
    param2: i64,
) callconv(@import("std").os.windows.WINAPI) i64;

pub extern "winsqlite3" fn sqlite3_uri_key(
    zFilename: ?[*:0]const u8,
    N: i32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_filename_database(
    param0: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_filename_journal(
    param0: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_filename_wal(
    param0: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_database_file_object(
    param0: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3_file;

pub extern "winsqlite3" fn sqlite3_create_filename(
    zDatabase: ?[*:0]const u8,
    zJournal: ?[*:0]const u8,
    zWal: ?[*:0]const u8,
    nParam: i32,
    azParam: ?*const ?*i8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_free_filename(
    param0: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_errcode(
    db: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_extended_errcode(
    db: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_errmsg(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_errmsg16(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_errstr(
    param0: i32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_limit(
    param0: ?*sqlite3,
    id: i32,
    newVal: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_prepare(
    db: ?*sqlite3,
    zSql: ?[*:0]const u8,
    nByte: i32,
    ppStmt: ?*?*sqlite3_stmt,
    pzTail: ?*const ?*i8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_prepare_v2(
    db: ?*sqlite3,
    zSql: ?[*:0]const u8,
    nByte: i32,
    ppStmt: ?*?*sqlite3_stmt,
    pzTail: ?*const ?*i8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_prepare_v3(
    db: ?*sqlite3,
    zSql: ?[*:0]const u8,
    nByte: i32,
    prepFlags: u32,
    ppStmt: ?*?*sqlite3_stmt,
    pzTail: ?*const ?*i8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_prepare16(
    db: ?*sqlite3,
    zSql: ?*const anyopaque,
    nByte: i32,
    ppStmt: ?*?*sqlite3_stmt,
    pzTail: ?*const ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_prepare16_v2(
    db: ?*sqlite3,
    zSql: ?*const anyopaque,
    nByte: i32,
    ppStmt: ?*?*sqlite3_stmt,
    pzTail: ?*const ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_prepare16_v3(
    db: ?*sqlite3,
    zSql: ?*const anyopaque,
    nByte: i32,
    prepFlags: u32,
    ppStmt: ?*?*sqlite3_stmt,
    pzTail: ?*const ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_sql(
    pStmt: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_expanded_sql(
    pStmt: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_stmt_readonly(
    pStmt: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_stmt_isexplain(
    pStmt: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_stmt_busy(
    param0: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_blob(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: ?*const anyopaque,
    n: i32,
    param4: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_blob64(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: ?*const anyopaque,
    param3: u64,
    param4: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_double(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: f64,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_int(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_int64(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: i64,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_null(
    param0: ?*sqlite3_stmt,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_text(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: ?[*:0]const u8,
    param3: i32,
    param4: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_text16(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: ?*const anyopaque,
    param3: i32,
    param4: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_text64(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: ?[*:0]const u8,
    param3: u64,
    param4: isize,
    encoding: u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_value(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: ?*const sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_pointer(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: ?*anyopaque,
    param3: ?[*:0]const u8,
    param4: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_zeroblob(
    param0: ?*sqlite3_stmt,
    param1: i32,
    n: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_zeroblob64(
    param0: ?*sqlite3_stmt,
    param1: i32,
    param2: u64,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_parameter_count(
    param0: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_bind_parameter_name(
    param0: ?*sqlite3_stmt,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_bind_parameter_index(
    param0: ?*sqlite3_stmt,
    zName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_clear_bindings(
    param0: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_column_count(
    pStmt: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_column_name(
    param0: ?*sqlite3_stmt,
    N: i32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_column_name16(
    param0: ?*sqlite3_stmt,
    N: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_column_database_name(
    param0: ?*sqlite3_stmt,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_column_database_name16(
    param0: ?*sqlite3_stmt,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_column_table_name(
    param0: ?*sqlite3_stmt,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_column_table_name16(
    param0: ?*sqlite3_stmt,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_column_origin_name(
    param0: ?*sqlite3_stmt,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_column_origin_name16(
    param0: ?*sqlite3_stmt,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_column_decltype(
    param0: ?*sqlite3_stmt,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_column_decltype16(
    param0: ?*sqlite3_stmt,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_step(
    param0: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_data_count(
    pStmt: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_column_blob(
    param0: ?*sqlite3_stmt,
    iCol: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_column_double(
    param0: ?*sqlite3_stmt,
    iCol: i32,
) callconv(@import("std").os.windows.WINAPI) f64;

pub extern "winsqlite3" fn sqlite3_column_int(
    param0: ?*sqlite3_stmt,
    iCol: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_column_int64(
    param0: ?*sqlite3_stmt,
    iCol: i32,
) callconv(@import("std").os.windows.WINAPI) i64;

pub extern "winsqlite3" fn sqlite3_column_text(
    param0: ?*sqlite3_stmt,
    iCol: i32,
) callconv(@import("std").os.windows.WINAPI) ?*u8;

pub extern "winsqlite3" fn sqlite3_column_text16(
    param0: ?*sqlite3_stmt,
    iCol: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_column_value(
    param0: ?*sqlite3_stmt,
    iCol: i32,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3_value;

pub extern "winsqlite3" fn sqlite3_column_bytes(
    param0: ?*sqlite3_stmt,
    iCol: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_column_bytes16(
    param0: ?*sqlite3_stmt,
    iCol: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_column_type(
    param0: ?*sqlite3_stmt,
    iCol: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_finalize(
    pStmt: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_reset(
    pStmt: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_create_function(
    db: ?*sqlite3,
    zFunctionName: ?[*:0]const u8,
    nArg: i32,
    eTextRep: i32,
    pApp: ?*anyopaque,
    xFunc: isize,
    xStep: isize,
    xFinal: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_create_function16(
    db: ?*sqlite3,
    zFunctionName: ?*const anyopaque,
    nArg: i32,
    eTextRep: i32,
    pApp: ?*anyopaque,
    xFunc: isize,
    xStep: isize,
    xFinal: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_create_function_v2(
    db: ?*sqlite3,
    zFunctionName: ?[*:0]const u8,
    nArg: i32,
    eTextRep: i32,
    pApp: ?*anyopaque,
    xFunc: isize,
    xStep: isize,
    xFinal: isize,
    xDestroy: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_create_window_function(
    db: ?*sqlite3,
    zFunctionName: ?[*:0]const u8,
    nArg: i32,
    eTextRep: i32,
    pApp: ?*anyopaque,
    xStep: isize,
    xFinal: isize,
    xValue: isize,
    xInverse: isize,
    xDestroy: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_aggregate_count(
    param0: ?*sqlite3_context,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_expired(
    param0: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_transfer_bindings(
    param0: ?*sqlite3_stmt,
    param1: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_global_recover() callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_thread_cleanup() callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_memory_alarm(
    param0: isize,
    param1: ?*anyopaque,
    param2: i64,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_value_blob(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_value_double(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) f64;

pub extern "winsqlite3" fn sqlite3_value_int(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_value_int64(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) i64;

pub extern "winsqlite3" fn sqlite3_value_pointer(
    param0: ?*sqlite3_value,
    param1: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_value_text(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) ?*u8;

pub extern "winsqlite3" fn sqlite3_value_text16(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_value_text16le(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_value_text16be(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_value_bytes(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_value_bytes16(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_value_type(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_value_numeric_type(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_value_nochange(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_value_frombind(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_value_subtype(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) u32;

pub extern "winsqlite3" fn sqlite3_value_dup(
    param0: ?*const sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3_value;

pub extern "winsqlite3" fn sqlite3_value_free(
    param0: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_aggregate_context(
    param0: ?*sqlite3_context,
    nBytes: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_user_data(
    param0: ?*sqlite3_context,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_context_db_handle(
    param0: ?*sqlite3_context,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3;

pub extern "winsqlite3" fn sqlite3_get_auxdata(
    param0: ?*sqlite3_context,
    N: i32,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_set_auxdata(
    param0: ?*sqlite3_context,
    N: i32,
    param2: ?*anyopaque,
    param3: isize,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_blob(
    param0: ?*sqlite3_context,
    param1: ?*const anyopaque,
    param2: i32,
    param3: isize,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_blob64(
    param0: ?*sqlite3_context,
    param1: ?*const anyopaque,
    param2: u64,
    param3: isize,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_double(
    param0: ?*sqlite3_context,
    param1: f64,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_error(
    param0: ?*sqlite3_context,
    param1: ?[*:0]const u8,
    param2: i32,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_error16(
    param0: ?*sqlite3_context,
    param1: ?*const anyopaque,
    param2: i32,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_error_toobig(
    param0: ?*sqlite3_context,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_error_nomem(
    param0: ?*sqlite3_context,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_error_code(
    param0: ?*sqlite3_context,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_int(
    param0: ?*sqlite3_context,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_int64(
    param0: ?*sqlite3_context,
    param1: i64,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_null(
    param0: ?*sqlite3_context,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_text(
    param0: ?*sqlite3_context,
    param1: ?[*:0]const u8,
    param2: i32,
    param3: isize,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_text64(
    param0: ?*sqlite3_context,
    param1: ?[*:0]const u8,
    param2: u64,
    param3: isize,
    encoding: u8,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_text16(
    param0: ?*sqlite3_context,
    param1: ?*const anyopaque,
    param2: i32,
    param3: isize,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_text16le(
    param0: ?*sqlite3_context,
    param1: ?*const anyopaque,
    param2: i32,
    param3: isize,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_text16be(
    param0: ?*sqlite3_context,
    param1: ?*const anyopaque,
    param2: i32,
    param3: isize,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_value(
    param0: ?*sqlite3_context,
    param1: ?*sqlite3_value,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_pointer(
    param0: ?*sqlite3_context,
    param1: ?*anyopaque,
    param2: ?[*:0]const u8,
    param3: isize,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_zeroblob(
    param0: ?*sqlite3_context,
    n: i32,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_result_zeroblob64(
    param0: ?*sqlite3_context,
    n: u64,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_result_subtype(
    param0: ?*sqlite3_context,
    param1: u32,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_create_collation(
    param0: ?*sqlite3,
    zName: ?[*:0]const u8,
    eTextRep: i32,
    pArg: ?*anyopaque,
    xCompare: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_create_collation_v2(
    param0: ?*sqlite3,
    zName: ?[*:0]const u8,
    eTextRep: i32,
    pArg: ?*anyopaque,
    xCompare: isize,
    xDestroy: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_create_collation16(
    param0: ?*sqlite3,
    zName: ?*const anyopaque,
    eTextRep: i32,
    pArg: ?*anyopaque,
    xCompare: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_collation_needed(
    param0: ?*sqlite3,
    param1: ?*anyopaque,
    param2: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_collation_needed16(
    param0: ?*sqlite3,
    param1: ?*anyopaque,
    param2: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_sleep(
    param0: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_win32_set_directory(
    type: u32,
    zValue: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_win32_set_directory8(
    type: u32,
    zValue: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_win32_set_directory16(
    type: u32,
    zValue: ?*const anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_get_autocommit(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_db_handle(
    param0: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3;

pub extern "winsqlite3" fn sqlite3_db_filename(
    db: ?*sqlite3,
    zDbName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_db_readonly(
    db: ?*sqlite3,
    zDbName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_txn_state(
    param0: ?*sqlite3,
    zSchema: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_next_stmt(
    pDb: ?*sqlite3,
    pStmt: ?*sqlite3_stmt,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3_stmt;

pub extern "winsqlite3" fn sqlite3_commit_hook(
    param0: ?*sqlite3,
    param1: isize,
    param2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_rollback_hook(
    param0: ?*sqlite3,
    param1: isize,
    param2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_update_hook(
    param0: ?*sqlite3,
    param1: isize,
    param2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_enable_shared_cache(
    param0: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_release_memory(
    param0: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_db_release_memory(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_soft_heap_limit64(
    N: i64,
) callconv(@import("std").os.windows.WINAPI) i64;

pub extern "winsqlite3" fn sqlite3_hard_heap_limit64(
    N: i64,
) callconv(@import("std").os.windows.WINAPI) i64;

pub extern "winsqlite3" fn sqlite3_soft_heap_limit(
    N: i32,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_table_column_metadata(
    db: ?*sqlite3,
    zDbName: ?[*:0]const u8,
    zTableName: ?[*:0]const u8,
    zColumnName: ?[*:0]const u8,
    pzDataType: ?*const ?*i8,
    pzCollSeq: ?*const ?*i8,
    pNotNull: ?*i32,
    pPrimaryKey: ?*i32,
    pAutoinc: ?*i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_load_extension(
    db: ?*sqlite3,
    zFile: ?[*:0]const u8,
    zProc: ?[*:0]const u8,
    pzErrMsg: ?*?*i8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_enable_load_extension(
    db: ?*sqlite3,
    onoff: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_auto_extension(
    xEntryPoint: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_cancel_auto_extension(
    xEntryPoint: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_reset_auto_extension() callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_create_module(
    db: ?*sqlite3,
    zName: ?[*:0]const u8,
    p: ?*const sqlite3_module,
    pClientData: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_create_module_v2(
    db: ?*sqlite3,
    zName: ?[*:0]const u8,
    p: ?*const sqlite3_module,
    pClientData: ?*anyopaque,
    xDestroy: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_drop_modules(
    db: ?*sqlite3,
    azKeep: ?*const ?*i8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_declare_vtab(
    param0: ?*sqlite3,
    zSQL: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_overload_function(
    param0: ?*sqlite3,
    zFuncName: ?[*:0]const u8,
    nArg: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_blob_open(
    param0: ?*sqlite3,
    zDb: ?[*:0]const u8,
    zTable: ?[*:0]const u8,
    zColumn: ?[*:0]const u8,
    iRow: i64,
    flags: i32,
    ppBlob: ?*?*sqlite3_blob,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_blob_reopen(
    param0: ?*sqlite3_blob,
    param1: i64,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_blob_close(
    param0: ?*sqlite3_blob,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_blob_bytes(
    param0: ?*sqlite3_blob,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_blob_read(
    param0: ?*sqlite3_blob,
    Z: ?*anyopaque,
    N: i32,
    iOffset: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_blob_write(
    param0: ?*sqlite3_blob,
    z: ?*const anyopaque,
    n: i32,
    iOffset: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_vfs_find(
    zVfsName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3_vfs;

pub extern "winsqlite3" fn sqlite3_vfs_register(
    param0: ?*sqlite3_vfs,
    makeDflt: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_vfs_unregister(
    param0: ?*sqlite3_vfs,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_mutex_alloc(
    param0: i32,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3_mutex;

pub extern "winsqlite3" fn sqlite3_mutex_free(
    param0: ?*sqlite3_mutex,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_mutex_enter(
    param0: ?*sqlite3_mutex,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_mutex_try(
    param0: ?*sqlite3_mutex,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_mutex_leave(
    param0: ?*sqlite3_mutex,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_db_mutex(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3_mutex;

pub extern "winsqlite3" fn sqlite3_file_control(
    param0: ?*sqlite3,
    zDbName: ?[*:0]const u8,
    op: i32,
    param3: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_test_control(
    op: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_keyword_count() callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_keyword_name(
    param0: i32,
    param1: ?*const ?*i8,
    param2: ?*i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_keyword_check(
    param0: ?[*:0]const u8,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_str_new(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3_str;

pub extern "winsqlite3" fn sqlite3_str_finish(
    param0: ?*sqlite3_str,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_str_appendf(
    param0: ?*sqlite3_str,
    zFormat: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_str_vappendf(
    param0: ?*sqlite3_str,
    zFormat: ?[*:0]const u8,
    param2: ?*i8,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_str_append(
    param0: ?*sqlite3_str,
    zIn: ?[*:0]const u8,
    N: i32,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_str_appendall(
    param0: ?*sqlite3_str,
    zIn: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_str_appendchar(
    param0: ?*sqlite3_str,
    N: i32,
    C: CHAR,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_str_reset(
    param0: ?*sqlite3_str,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_str_errcode(
    param0: ?*sqlite3_str,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_str_length(
    param0: ?*sqlite3_str,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_str_value(
    param0: ?*sqlite3_str,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_status(
    op: i32,
    pCurrent: ?*i32,
    pHighwater: ?*i32,
    resetFlag: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_status64(
    op: i32,
    pCurrent: ?*i64,
    pHighwater: ?*i64,
    resetFlag: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_db_status(
    param0: ?*sqlite3,
    op: i32,
    pCur: ?*i32,
    pHiwtr: ?*i32,
    resetFlg: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_stmt_status(
    param0: ?*sqlite3_stmt,
    op: i32,
    resetFlg: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_backup_init(
    pDest: ?*sqlite3,
    zDestName: ?[*:0]const u8,
    pSource: ?*sqlite3,
    zSourceName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*sqlite3_backup;

pub extern "winsqlite3" fn sqlite3_backup_step(
    p: ?*sqlite3_backup,
    nPage: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_backup_finish(
    p: ?*sqlite3_backup,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_backup_remaining(
    p: ?*sqlite3_backup,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_backup_pagecount(
    p: ?*sqlite3_backup,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_stricmp(
    param0: ?[*:0]const u8,
    param1: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_strnicmp(
    param0: ?[*:0]const u8,
    param1: ?[*:0]const u8,
    param2: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_strglob(
    zGlob: ?[*:0]const u8,
    zStr: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_strlike(
    zGlob: ?[*:0]const u8,
    zStr: ?[*:0]const u8,
    cEsc: u32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_log(
    iErrCode: i32,
    zFormat: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "winsqlite3" fn sqlite3_wal_hook(
    param0: ?*sqlite3,
    param1: isize,
    param2: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;

pub extern "winsqlite3" fn sqlite3_wal_autocheckpoint(
    db: ?*sqlite3,
    N: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_wal_checkpoint(
    db: ?*sqlite3,
    zDb: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_wal_checkpoint_v2(
    db: ?*sqlite3,
    zDb: ?[*:0]const u8,
    eMode: i32,
    pnLog: ?*i32,
    pnCkpt: ?*i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_vtab_config(
    param0: ?*sqlite3,
    op: i32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_vtab_on_conflict(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_vtab_nochange(
    param0: ?*sqlite3_context,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_vtab_collation(
    param0: ?*sqlite3_index_info,
    param1: i32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;

pub extern "winsqlite3" fn sqlite3_db_cacheflush(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_system_errno(
    param0: ?*sqlite3,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_serialize(
    db: ?*sqlite3,
    zSchema: ?[*:0]const u8,
    piSize: ?*i64,
    mFlags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*u8;

pub extern "winsqlite3" fn sqlite3_deserialize(
    db: ?*sqlite3,
    zSchema: ?[*:0]const u8,
    pData: ?*u8,
    szDb: i64,
    szBuf: i64,
    mFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_rtree_geometry_callback(
    db: ?*sqlite3,
    zGeom: ?[*:0]const u8,
    xGeom: isize,
    pContext: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;

pub extern "winsqlite3" fn sqlite3_rtree_query_callback(
    db: ?*sqlite3,
    zQueryFunc: ?[*:0]const u8,
    xQueryFunc: isize,
    pContext: ?*anyopaque,
    xDestructor: isize,
) callconv(@import("std").os.windows.WINAPI) i32;

//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
    .ansi => struct {},
    .wide => struct {},
    .unspecified => if (@import("builtin").is_test) struct {} else struct {},
};
//--------------------------------------------------------------------------------
// Section: Imports (2)
//--------------------------------------------------------------------------------
const CHAR = @import("../foundation.zig").CHAR;
const PSTR = @import("../foundation.zig").PSTR;

test {
    // The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
    if (@hasDecl(@This(), "sqlite3_callback")) {
        _ = sqlite3_callback;
    }
    if (@hasDecl(@This(), "sqlite3_syscall_ptr")) {
        _ = sqlite3_syscall_ptr;
    }
    if (@hasDecl(@This(), "sqlite3_destructor_type")) {
        _ = sqlite3_destructor_type;
    }
    if (@hasDecl(@This(), "fts5_extension_function")) {
        _ = fts5_extension_function;
    }
    if (@hasDecl(@This(), "sqlite3_loadext_entry")) {
        _ = sqlite3_loadext_entry;
    }

    @setEvalBranchQuota(comptime @import("std").meta.declarations(@This()).len * 3);

    // reference all the pub declarations
    if (!@import("builtin").is_test) return;
    inline for (comptime @import("std").meta.declarations(@This())) |decl| {
        if (decl.is_pub) {
            _ = @field(@This(), decl.name);
        }
    }
}
