@evolu/sqlite-wasm 2.2.4 → 3.53.4-build1

package/dist/src/CApi.d.ts

@@ -0,0 +1,2108 @@
+/**
+ * SQLite's C API as standalone functions: one for every public C function the
+ * binary exports, and one for each of the variadic {@link sqlite3_config},
+ * {@link sqlite3_db_config} and {@link sqlite3_vtab_config}, which the binary
+ * exports only as the build's `sqlite3__wasm_*` shims.
+ *
+ * Each function takes {@link SqliteWasmDep} and returns the wasm export itself,
+ * typed with branded pointers and raw result codes, so a call costs no
+ * JavaScript wrapper. A variadic function whose options need different shims
+ * returns a function that passes each option to its shim, as SQLite's
+ * JavaScript does. Bind once per database, never per row. Strings are C string
+ * pointers; nothing allocates implicitly. A callback parameter takes a function
+ * pointer, such as one {@link installWasmFunctions} returns.
+ *
+ * Each function's documentation gives its wasm type and its signature in the
+ * syntax of SQLite's table, where `funcptr:` and the callback's signature stand
+ * for a callback argument.
+ *
+ * Generated by `scripts/generate.mts` from SQLite's own signature table in
+ * `scripts/upstream/sqlite3-api-glue.c-pp.js` and the metadata in
+ * `scripts/bindings.mts`, with every wasm type checked against the binary's
+ * pinned exports. Do not edit.
+ *
+ * @module
+ */
+import { SQLITE_CONFIG_COVERING_INDEX_SCAN, SQLITE_CONFIG_LOOKASIDE, SQLITE_CONFIG_MEMDB_MAXSIZE, SQLITE_CONFIG_MEMSTATUS, SQLITE_CONFIG_SMALL_MALLOC, SQLITE_CONFIG_SORTERREF_SIZE, SQLITE_CONFIG_STMTJRNL_SPILL, SQLITE_CONFIG_URI, SQLITE_DBCONFIG_DEFENSIVE, SQLITE_DBCONFIG_DQS_DDL, SQLITE_DBCONFIG_DQS_DML, SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE, SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE, SQLITE_DBCONFIG_ENABLE_COMMENTS, SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_DBCONFIG_ENABLE_QPSG, SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_DBCONFIG_ENABLE_VIEW, SQLITE_DBCONFIG_FP_DIGITS, SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, SQLITE_DBCONFIG_LEGACY_FILE_FORMAT, SQLITE_DBCONFIG_LOOKASIDE, SQLITE_DBCONFIG_MAINDBNAME, SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, SQLITE_DBCONFIG_RESET_DATABASE, SQLITE_DBCONFIG_REVERSE_SCANORDER, SQLITE_DBCONFIG_STMT_SCANSTATUS, SQLITE_DBCONFIG_TRIGGER_EQP, SQLITE_DBCONFIG_TRUSTED_SCHEMA, SQLITE_DBCONFIG_WRITABLE_SCHEMA, type SQLITE_VTAB_CONSTRAINT_SUPPORT, type SQLITE_VTAB_DIRECTONLY, type SQLITE_VTAB_INNOCUOUS, type SqliteDataType, type SqliteResultCode } from "./Constants.ts";
+import type { CStringPtr, NullPtr, SqliteContextPtr, SqliteDbPtr, SqliteDestructor, SqliteFilenamePtr, SqliteFunctionPtr, SqliteIndexInfoPtr, SqliteOwnedCStringPtr, SqliteOwnedPtr, SqliteOwnedValuePtr, SqliteStmtPtr, SqliteValuePtr, SqliteVfsPtr, WasmPtr } from "./Pointer.ts";
+import type { SqliteWasmDep } from "./Wasm.ts";
+/**
+ * The C functions this package binds, and the build's shims of the variadic
+ * ones, as the wasm exports them.
+ */
+export interface SqliteCExports {
+    readonly sqlite3_initialize: () => SqliteResultCode;
+    readonly sqlite3_shutdown: () => SqliteResultCode;
+    readonly sqlite3_libversion: () => CStringPtr;
+    readonly sqlite3_libversion_number: () => number;
+    readonly sqlite3_sourceid: () => CStringPtr;
+    readonly sqlite3_compileoption_get: (N: number) => CStringPtr | NullPtr;
+    readonly sqlite3_compileoption_used: (zOptName: CStringPtr) => number;
+    readonly sqlite3_status: (op: number, pCurrent: WasmPtr, pHighwater: WasmPtr, resetFlag: number) => SqliteResultCode;
+    readonly sqlite3_status64: (op: number, pCurrent: WasmPtr, pHighwater: WasmPtr, resetFlag: number) => SqliteResultCode;
+    readonly sqlite3_auto_extension: (xEntryPoint: SqliteFunctionPtr) => SqliteResultCode;
+    readonly sqlite3_cancel_auto_extension: (xEntryPoint: SqliteFunctionPtr) => number;
+    readonly sqlite3_reset_auto_extension: () => void;
+    readonly sqlite3_randomness: (N: number, P: WasmPtr | NullPtr) => void;
+    readonly sqlite3_complete: (sql: CStringPtr) => number;
+    readonly sqlite3_keyword_count: () => number;
+    readonly sqlite3_keyword_name: (index: number, pzName: WasmPtr, pnName: WasmPtr) => SqliteResultCode;
+    readonly sqlite3_keyword_check: (zName: WasmPtr, nName: number) => number;
+    readonly sqlite3_strglob: (zGlob: CStringPtr, zStr: CStringPtr) => number;
+    readonly sqlite3_strlike: (zGlob: CStringPtr, zStr: CStringPtr, cEsc: number) => number;
+    readonly sqlite3_stricmp: (zLeft: CStringPtr, zRight: CStringPtr) => number;
+    readonly sqlite3_strnicmp: (zLeft: CStringPtr, zRight: CStringPtr, N: number) => number;
+    readonly sqlite3_malloc: (byteLength: number) => SqliteOwnedPtr | NullPtr;
+    readonly sqlite3_malloc64: (byteLength: bigint) => SqliteOwnedPtr | NullPtr;
+    readonly sqlite3_realloc: (ptr: SqliteOwnedPtr | NullPtr, byteLength: number) => SqliteOwnedPtr | NullPtr;
+    readonly sqlite3_realloc64: (ptr: SqliteOwnedPtr | NullPtr, byteLength: bigint) => SqliteOwnedPtr | NullPtr;
+    readonly sqlite3_msize: (ptr: SqliteOwnedPtr | NullPtr) => bigint;
+    readonly sqlite3_free: (ptr: SqliteOwnedPtr | NullPtr) => void;
+    readonly sqlite3_open: (filename: CStringPtr, ppDb: WasmPtr) => SqliteResultCode;
+    readonly sqlite3_open_v2: (filename: CStringPtr, ppDb: WasmPtr, flags: number, zVfs: CStringPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_close_v2: (db: SqliteDbPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_db_filename: (db: SqliteDbPtr, zDbName: CStringPtr) => SqliteFilenamePtr | NullPtr;
+    readonly sqlite3_db_name: (db: SqliteDbPtr, N: number) => CStringPtr | NullPtr;
+    readonly sqlite3_db_readonly: (db: SqliteDbPtr, zDbName: CStringPtr) => number;
+    readonly sqlite3_txn_state: (db: SqliteDbPtr, zSchema: CStringPtr | NullPtr) => number;
+    readonly sqlite3_get_autocommit: (db: SqliteDbPtr) => number;
+    readonly sqlite3_limit: (db: SqliteDbPtr, id: number, newVal: number) => number;
+    readonly sqlite3_busy_handler: (db: SqliteDbPtr, xBusy: SqliteFunctionPtr | NullPtr, pArg: WasmPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_busy_timeout: (db: SqliteDbPtr, ms: number) => SqliteResultCode;
+    readonly sqlite3_interrupt: (db: SqliteDbPtr) => void;
+    readonly sqlite3_is_interrupted: (db: SqliteDbPtr) => number;
+    readonly sqlite3_extended_result_codes: (db: SqliteDbPtr, onoff: number) => SqliteResultCode;
+    readonly sqlite3_file_control: (db: SqliteDbPtr, zDbName: CStringPtr | NullPtr, op: number, pArg: WasmPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_table_column_metadata: (db: SqliteDbPtr, zDbName: CStringPtr | NullPtr, zTableName: CStringPtr, zColumnName: CStringPtr | NullPtr, pzDataType: WasmPtr | NullPtr, pzCollSeq: WasmPtr | NullPtr, pNotNull: WasmPtr | NullPtr, pPrimaryKey: WasmPtr | NullPtr, pAutoinc: WasmPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_db_status: (db: SqliteDbPtr, op: number, pCur: WasmPtr, pHiwtr: WasmPtr, resetFlg: number) => SqliteResultCode;
+    readonly sqlite3_db_status64: (db: SqliteDbPtr, op: number, pCur: WasmPtr, pHiwtr: WasmPtr, resetFlg: number) => SqliteResultCode;
+    readonly sqlite3_last_insert_rowid: (db: SqliteDbPtr) => bigint;
+    readonly sqlite3_set_last_insert_rowid: (db: SqliteDbPtr, rowid: bigint) => void;
+    readonly sqlite3_changes: (db: SqliteDbPtr) => number;
+    readonly sqlite3_changes64: (db: SqliteDbPtr) => bigint;
+    readonly sqlite3_total_changes: (db: SqliteDbPtr) => number;
+    readonly sqlite3_total_changes64: (db: SqliteDbPtr) => bigint;
+    readonly sqlite3_exec: (db: SqliteDbPtr, sql: CStringPtr | NullPtr, callback: SqliteFunctionPtr | NullPtr, pArg: WasmPtr | NullPtr, errmsg: WasmPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_serialize: {
+        (db: SqliteDbPtr, zSchema: CStringPtr | NullPtr, piSize: WasmPtr | NullPtr, mFlags: 0): SqliteOwnedPtr | NullPtr;
+        (db: SqliteDbPtr, zSchema: CStringPtr | NullPtr, piSize: WasmPtr | NullPtr, mFlags: number): WasmPtr | NullPtr;
+    };
+    readonly sqlite3_deserialize: (db: SqliteDbPtr, zSchema: CStringPtr | NullPtr, pData: WasmPtr, szDb: bigint, szBuf: bigint, mFlags: number) => SqliteResultCode;
+    readonly sqlite3_errcode: (db: SqliteDbPtr) => SqliteResultCode;
+    readonly sqlite3_extended_errcode: (db: SqliteDbPtr) => SqliteResultCode;
+    readonly sqlite3_errmsg: (db: SqliteDbPtr) => CStringPtr | NullPtr;
+    readonly sqlite3_errstr: (code: SqliteResultCode) => CStringPtr | NullPtr;
+    readonly sqlite3_error_offset: (db: SqliteDbPtr) => number;
+    readonly sqlite3_set_errmsg: (db: SqliteDbPtr, errcode: SqliteResultCode, zErrMsg: CStringPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_commit_hook: (db: SqliteDbPtr, xCallback: SqliteFunctionPtr | NullPtr, pArg: WasmPtr | NullPtr) => WasmPtr | NullPtr;
+    readonly sqlite3_rollback_hook: (db: SqliteDbPtr, xCallback: SqliteFunctionPtr | NullPtr, pArg: WasmPtr | NullPtr) => WasmPtr | NullPtr;
+    readonly sqlite3_update_hook: (db: SqliteDbPtr, xCallback: SqliteFunctionPtr | NullPtr, pArg: WasmPtr | NullPtr) => WasmPtr | NullPtr;
+    readonly sqlite3_trace_v2: (db: SqliteDbPtr, uMask: number, xCallback: SqliteFunctionPtr | NullPtr, pCtx: WasmPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_collation_needed: (db: SqliteDbPtr, pArg: WasmPtr | NullPtr, xCollNeeded: SqliteFunctionPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_prepare_v2: (db: SqliteDbPtr, zSql: WasmPtr, nByte: number, ppStmt: WasmPtr, pzTail: WasmPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_prepare_v3: (db: SqliteDbPtr, zSql: WasmPtr, nByte: number, prepFlags: number, ppStmt: WasmPtr, pzTail: WasmPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_step: (pStmt: SqliteStmtPtr) => SqliteResultCode;
+    readonly sqlite3_reset: (pStmt: SqliteStmtPtr) => SqliteResultCode;
+    readonly sqlite3_finalize: (pStmt: SqliteStmtPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_next_stmt: (pDb: SqliteDbPtr, pStmt: SqliteStmtPtr | NullPtr) => SqliteStmtPtr | NullPtr;
+    readonly sqlite3_db_handle: (pStmt: SqliteStmtPtr) => SqliteDbPtr;
+    readonly sqlite3_sql: (pStmt: SqliteStmtPtr) => CStringPtr | NullPtr;
+    readonly sqlite3_expanded_sql: (pStmt: SqliteStmtPtr) => SqliteOwnedCStringPtr | NullPtr;
+    readonly sqlite3_stmt_busy: (pStmt: SqliteStmtPtr | NullPtr) => number;
+    readonly sqlite3_stmt_readonly: (pStmt: SqliteStmtPtr) => number;
+    readonly sqlite3_stmt_explain: (pStmt: SqliteStmtPtr, eMode: number) => SqliteResultCode;
+    readonly sqlite3_stmt_isexplain: (pStmt: SqliteStmtPtr | NullPtr) => number;
+    readonly sqlite3_stmt_status: (pStmt: SqliteStmtPtr, op: number, resetFlg: number) => number;
+    readonly sqlite3_bind_parameter_count: (pStmt: SqliteStmtPtr) => number;
+    readonly sqlite3_bind_parameter_index: (pStmt: SqliteStmtPtr, zName: CStringPtr) => number;
+    readonly sqlite3_bind_parameter_name: (pStmt: SqliteStmtPtr, index: number) => CStringPtr | NullPtr;
+    readonly sqlite3_bind_null: (pStmt: SqliteStmtPtr, index: number) => SqliteResultCode;
+    readonly sqlite3_bind_int: (pStmt: SqliteStmtPtr, index: number, value: number) => SqliteResultCode;
+    readonly sqlite3_bind_int64: (pStmt: SqliteStmtPtr, index: number, value: bigint) => SqliteResultCode;
+    readonly sqlite3_bind_double: (pStmt: SqliteStmtPtr, index: number, value: number) => SqliteResultCode;
+    readonly sqlite3_bind_text: (pStmt: SqliteStmtPtr, index: number, value: WasmPtr | NullPtr, n: number, destructor: SqliteDestructor) => SqliteResultCode;
+    readonly sqlite3_bind_blob: (pStmt: SqliteStmtPtr, index: number, value: WasmPtr | NullPtr, n: number, destructor: SqliteDestructor) => SqliteResultCode;
+    readonly sqlite3_bind_zeroblob: (pStmt: SqliteStmtPtr, index: number, n: number) => SqliteResultCode;
+    readonly sqlite3_bind_pointer: (pStmt: SqliteStmtPtr, index: number, pPtr: WasmPtr | NullPtr, zPType: CStringPtr, xDestructor: SqliteFunctionPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_clear_bindings: (pStmt: SqliteStmtPtr) => SqliteResultCode;
+    readonly sqlite3_column_count: (pStmt: SqliteStmtPtr) => number;
+    readonly sqlite3_data_count: (pStmt: SqliteStmtPtr | NullPtr) => number;
+    readonly sqlite3_column_name: (pStmt: SqliteStmtPtr, N: number) => CStringPtr | NullPtr;
+    readonly sqlite3_column_decltype: (pStmt: SqliteStmtPtr, iCol: number) => CStringPtr | NullPtr;
+    readonly sqlite3_column_type: (pStmt: SqliteStmtPtr, iCol: number) => SqliteDataType;
+    readonly sqlite3_column_int: (pStmt: SqliteStmtPtr, iCol: number) => number;
+    readonly sqlite3_column_int64: (pStmt: SqliteStmtPtr, iCol: number) => bigint;
+    readonly sqlite3_column_double: (pStmt: SqliteStmtPtr, iCol: number) => number;
+    readonly sqlite3_column_text: (pStmt: SqliteStmtPtr, iCol: number) => WasmPtr | NullPtr;
+    readonly sqlite3_column_blob: (pStmt: SqliteStmtPtr, iCol: number) => WasmPtr | NullPtr;
+    readonly sqlite3_column_bytes: (pStmt: SqliteStmtPtr, iCol: number) => number;
+    readonly sqlite3_column_value: (pStmt: SqliteStmtPtr, iCol: number) => SqliteValuePtr;
+    readonly sqlite3_value_type: (value: SqliteValuePtr) => SqliteDataType;
+    readonly sqlite3_value_numeric_type: (value: SqliteValuePtr) => SqliteDataType;
+    readonly sqlite3_value_int: (value: SqliteValuePtr) => number;
+    readonly sqlite3_value_int64: (value: SqliteValuePtr) => bigint;
+    readonly sqlite3_value_double: (value: SqliteValuePtr) => number;
+    readonly sqlite3_value_text: (value: SqliteValuePtr) => WasmPtr | NullPtr;
+    readonly sqlite3_value_blob: (value: SqliteValuePtr) => WasmPtr | NullPtr;
+    readonly sqlite3_value_bytes: (value: SqliteValuePtr) => number;
+    readonly sqlite3_value_pointer: (value: SqliteValuePtr, zPType: CStringPtr) => WasmPtr | NullPtr;
+    readonly sqlite3_value_subtype: (value: SqliteValuePtr) => number;
+    readonly sqlite3_value_frombind: (value: SqliteValuePtr) => number;
+    readonly sqlite3_value_nochange: (value: SqliteValuePtr) => number;
+    readonly sqlite3_value_dup: (value: SqliteValuePtr | NullPtr) => SqliteOwnedValuePtr | NullPtr;
+    readonly sqlite3_value_free: (value: SqliteOwnedValuePtr | NullPtr) => void;
+    readonly sqlite3_create_function: (db: SqliteDbPtr, zFunctionName: CStringPtr, nArg: number, eTextRep: number, pApp: WasmPtr | NullPtr, xFunc: SqliteFunctionPtr | NullPtr, xStep: SqliteFunctionPtr | NullPtr, xFinal: SqliteFunctionPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_create_function_v2: (db: SqliteDbPtr, zFunctionName: CStringPtr, nArg: number, eTextRep: number, pApp: WasmPtr | NullPtr, xFunc: SqliteFunctionPtr | NullPtr, xStep: SqliteFunctionPtr | NullPtr, xFinal: SqliteFunctionPtr | NullPtr, xDestroy: SqliteFunctionPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_overload_function: (db: SqliteDbPtr, zFuncName: CStringPtr, nArg: number) => SqliteResultCode;
+    readonly sqlite3_create_collation: (db: SqliteDbPtr, zName: CStringPtr, eTextRep: number, pArg: WasmPtr | NullPtr, xCompare: SqliteFunctionPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_create_collation_v2: (db: SqliteDbPtr, zName: CStringPtr, eTextRep: number, pArg: WasmPtr | NullPtr, xCompare: SqliteFunctionPtr | NullPtr, xDestroy: SqliteFunctionPtr | NullPtr) => SqliteResultCode;
+    readonly sqlite3_user_data: (context: SqliteContextPtr) => WasmPtr | NullPtr;
+    readonly sqlite3_context_db_handle: (context: SqliteContextPtr) => SqliteDbPtr;
+    readonly sqlite3_aggregate_context: (context: SqliteContextPtr, nBytes: number) => WasmPtr | NullPtr;
+    readonly sqlite3_get_auxdata: (context: SqliteContextPtr, N: number) => WasmPtr | NullPtr;
+    readonly sqlite3_set_auxdata: (context: SqliteContextPtr, N: number, pAux: WasmPtr | NullPtr, xDelete: SqliteFunctionPtr | NullPtr) => void;
+    readonly sqlite3_result_null: (context: SqliteContextPtr) => void;
+    readonly sqlite3_result_int: (context: SqliteContextPtr, value: number) => void;
+    readonly sqlite3_result_int64: (context: SqliteContextPtr, value: bigint) => void;
+    readonly sqlite3_result_double: (context: SqliteContextPtr, value: number) => void;
+    readonly sqlite3_result_text: (context: SqliteContextPtr, value: WasmPtr | NullPtr, n: number, destructor: SqliteDestructor) => void;
+    readonly sqlite3_result_blob: (context: SqliteContextPtr, value: WasmPtr | NullPtr, n: number, destructor: SqliteDestructor) => void;
+    readonly sqlite3_result_zeroblob: (context: SqliteContextPtr, n: number) => void;
+    readonly sqlite3_result_zeroblob64: (context: SqliteContextPtr, n: bigint) => SqliteResultCode;
+    readonly sqlite3_result_pointer: (context: SqliteContextPtr, pPtr: WasmPtr | NullPtr, zPType: CStringPtr, xDestructor: SqliteFunctionPtr | NullPtr) => void;
+    readonly sqlite3_result_subtype: (context: SqliteContextPtr, subtype: number) => void;
+    readonly sqlite3_result_error: (context: SqliteContextPtr, message: WasmPtr, n: number) => void;
+    readonly sqlite3_result_error_code: (context: SqliteContextPtr, code: SqliteResultCode) => void;
+    readonly sqlite3_result_error_nomem: (context: SqliteContextPtr) => void;
+    readonly sqlite3_result_error_toobig: (context: SqliteContextPtr) => void;
+    readonly sqlite3_uri_parameter: (z: SqliteFilenamePtr | NullPtr, zParam: CStringPtr) => CStringPtr | NullPtr;
+    readonly sqlite3_uri_boolean: (z: SqliteFilenamePtr | NullPtr, zParam: CStringPtr, bDefault: number) => number;
+    readonly sqlite3_uri_int64: (z: SqliteFilenamePtr | NullPtr, zParam: CStringPtr, iDefault: bigint) => bigint;
+    readonly sqlite3_uri_key: (z: SqliteFilenamePtr, N: number) => CStringPtr | NullPtr;
+    readonly sqlite3_vfs_find: (zVfsName: CStringPtr | NullPtr) => SqliteVfsPtr | NullPtr;
+    readonly sqlite3_vfs_register: (vfs: SqliteVfsPtr, makeDflt: number) => SqliteResultCode;
+    readonly sqlite3_vfs_unregister: (vfs: SqliteVfsPtr) => SqliteResultCode;
+    readonly sqlite3_vtab_on_conflict: (db: SqliteDbPtr) => number;
+    readonly sqlite3_vtab_nochange: (context: SqliteContextPtr) => number;
+    readonly sqlite3_vtab_collation: (indexInfo: SqliteIndexInfoPtr, iCons: number) => CStringPtr | NullPtr;
+    readonly sqlite3_vtab_distinct: (indexInfo: SqliteIndexInfoPtr) => number;
+    readonly sqlite3_vtab_in: (indexInfo: SqliteIndexInfoPtr, iCons: number, bHandle: number) => number;
+    readonly sqlite3_vtab_in_first: (pVal: SqliteValuePtr, ppOut: WasmPtr) => SqliteResultCode;
+    readonly sqlite3_vtab_in_next: (pVal: SqliteValuePtr, ppOut: WasmPtr) => SqliteResultCode;
+    readonly sqlite3_vtab_rhs_value: (indexInfo: SqliteIndexInfoPtr, iCons: number, ppVal: WasmPtr) => SqliteResultCode;
+    /**
+     * The build's shim that calls {@link sqlite3_config} with one int for any
+     * option, unchecked. sqlite3_config calls it only for the options that take
+     * an int.
+     *
+     * Wasm type `i(ii)`.
+     */
+    readonly sqlite3__wasm_config_i: (op: number, value: number) => SqliteResultCode;
+    /**
+     * The build's shim that calls {@link sqlite3_config} with two ints for any
+     * option, unchecked. sqlite3_config calls it only for
+     * SQLITE_CONFIG_LOOKASIDE.
+     *
+     * Wasm type `i(iii)`.
+     */
+    readonly sqlite3__wasm_config_ii: (op: number, sz: number, cnt: number) => SqliteResultCode;
+    /**
+     * The build's shim that calls {@link sqlite3_config} with a 64-bit integer for
+     * any option, unchecked. sqlite3_config calls it only for
+     * SQLITE_CONFIG_MEMDB_MAXSIZE.
+     *
+     * Wasm type `i(ij)`.
+     */
+    readonly sqlite3__wasm_config_j: (op: number, value: bigint) => SqliteResultCode;
+    /**
+     * The build's shim that calls {@link sqlite3_db_config} with a string for
+     * SQLITE_DBCONFIG_MAINDBNAME, and returns SQLITE_MISUSE for any other
+     * option.
+     *
+     * Wasm type `i(iii)`.
+     */
+    readonly sqlite3__wasm_db_config_s: (db: SqliteDbPtr, op: number, zName: CStringPtr) => SqliteResultCode;
+    /**
+     * The build's shim that calls {@link sqlite3_db_config} with a pointer and two
+     * ints for SQLITE_DBCONFIG_LOOKASIDE, and returns SQLITE_MISUSE for any other
+     * option.
+     *
+     * Wasm type `i(iiiii)`.
+     */
+    readonly sqlite3__wasm_db_config_pii: (db: SqliteDbPtr, op: number, buf: WasmPtr | NullPtr, sz: number, cnt: number) => SqliteResultCode;
+    /**
+     * The build's shim that calls {@link sqlite3_db_config} with an int and an
+     * `int*` for the options that take them, and returns SQLITE_MISUSE for any
+     * other option.
+     *
+     * Wasm type `i(iiii)`.
+     */
+    readonly sqlite3__wasm_db_config_ip: (db: SqliteDbPtr, op: number, value: number, pResult: WasmPtr | NullPtr) => SqliteResultCode;
+    /**
+     * The build's shim that calls {@link sqlite3_vtab_config} with an int for
+     * SQLITE_VTAB_CONSTRAINT_SUPPORT and without it for SQLITE_VTAB_INNOCUOUS and
+     * SQLITE_VTAB_DIRECTONLY, and returns SQLITE_MISUSE for any other option.
+     *
+     * Wasm type `i(iii)`.
+     */
+    readonly sqlite3__wasm_vtab_config: (db: SqliteDbPtr, op: number, value: number) => SqliteResultCode;
+}
+/**
+ * Initializes the library, returning SQLITE_OK or an error code. Once the
+ * library is initialized, further calls are harmless no-ops until
+ * {@link sqlite3_shutdown}.
+ *
+ * Wasm type `i()`. Signature `["sqlite3_initialize", undefined]` from SQLite's
+ * table, with the result corrected: SQLite's table declares no result, but the
+ * C function returns a result code, as the wasm type shows.
+ *
+ * See https://sqlite.org/c3ref/initialize.html.
+ */
+export declare const sqlite3_initialize: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_initialize"];
+/**
+ * Deallocates the resources {@link sqlite3_initialize} allocated. Every
+ * connection must be closed and every other SQLite resource freed first; only
+ * the first call after an initialization has an effect. Then initialize the
+ * library again with initializeSqliteWasm. sqlite3_initialize alone, or any
+ * call that initializes the library itself, such as an open, makes the unix VFS
+ * the default again, from which the generator of {@link sqlite3_randomness},
+ * when reset or unused since loading, seeds itself with the time and a constant
+ * pid instead of RandomBytes, and registers kvvfs again, which traps when
+ * :localStorage: is opened.
+ *
+ * Wasm type `i()`. Signature `["sqlite3_shutdown", undefined]` from SQLite's
+ * table, with the result corrected: SQLite's table declares no result, but the
+ * C function returns a result code, as the wasm type shows.
+ *
+ * See https://sqlite.org/c3ref/initialize.html.
+ */
+export declare const sqlite3_shutdown: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_shutdown"];
+/**
+ * Returns the library's version string, the SQLITE_VERSION it was built with,
+ * in static memory.
+ *
+ * Wasm type `i()`. Signature `["sqlite3_libversion", "string"]` from SQLite's
+ * table.
+ *
+ * See https://sqlite.org/c3ref/libversion.html.
+ */
+export declare const sqlite3_libversion: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_libversion"];
+/**
+ * Returns the SQLITE_VERSION_NUMBER the library was built with.
+ *
+ * Wasm type `i()`. Signature `["sqlite3_libversion_number", "int"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/libversion.html.
+ */
+export declare const sqlite3_libversion_number: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_libversion_number"];
+/**
+ * Returns the date, time and check-in hash of the SQLite source the library was
+ * built from, as a static string.
+ *
+ * Wasm type `i()`. Signature `["sqlite3_sourceid", "string"]` from SQLite's
+ * table.
+ *
+ * See https://sqlite.org/c3ref/libversion.html.
+ */
+export declare const sqlite3_sourceid: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_sourceid"];
+/**
+ * Returns the N-th option defined at compile time, without its SQLITE_ prefix,
+ * or NULL when N is out of range. The string is static.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_compileoption_get", "string", "int"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/compileoption_get.html.
+ */
+export declare const sqlite3_compileoption_get: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_compileoption_get"];
+/**
+ * Returns 1 if the named option, with or without its SQLITE_ prefix, was
+ * defined at compile time, and 0 otherwise.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_compileoption_used", "int", "string"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/compileoption_get.html.
+ */
+export declare const sqlite3_compileoption_used: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_compileoption_used"];
+/**
+ * Reads a global SQLITE_STATUS_* counter into `*pCurrent` and its highwater
+ * mark into `*pHighwater`, resetting the mark when resetFlag is non-zero. A
+ * counter that tracks only one of the two leaves the other unwritten, and
+ * values beyond 32 bits are undefined.
+ *
+ * Wasm type `i(iiii)`. Signature `["sqlite3_status", "int", "int", "*", "*",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/status.html.
+ */
+export declare const sqlite3_status: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_status"];
+/**
+ * Reads a global SQLITE_STATUS_* counter into the sqlite3_int64 at pCurrent and
+ * its highwater mark into the sqlite3_int64 at pHighwater, 8 bytes each,
+ * resetting the mark when resetFlag is non-zero. Some counters leave one of the
+ * two outputs unwritten.
+ *
+ * Wasm type `i(iiii)`. Signature `["sqlite3_status64", "int", "int", "*", "*",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/status.html.
+ */
+export declare const sqlite3_status64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_status64"];
+/**
+ * Registers an entry point that SQLite calls for every new connection, where an
+ * error it returns fails the open; registering one twice is a no-op. Despite
+ * the `void (*)(void)` prototype SQLite calls it as `int xEntryPoint(sqlite3
+ * *db, char **pzErrMsg, const sqlite3_api_routines *pThunk)`, so its function
+ * table entry must have that type.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_auto_extension", "int",
+ * "funcptr:i(ppp)"]` from Evolu's supplement: SQLite binds the auto-extension
+ * functions by hand to manage the JavaScript functions it converts.
+ *
+ * See https://sqlite.org/c3ref/auto_extension.html.
+ */
+export declare const sqlite3_auto_extension: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_auto_extension"];
+/**
+ * Unregisters an entry point {@link sqlite3_auto_extension} registered,
+ * returning 1 when it was registered and 0 otherwise.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_cancel_auto_extension", "int",
+ * "funcptr:i(ppp)"]` from Evolu's supplement: SQLite binds the auto-extension
+ * functions by hand to manage the JavaScript functions it converts.
+ *
+ * See https://sqlite.org/c3ref/cancel_auto_extension.html.
+ */
+export declare const sqlite3_cancel_auto_extension: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_cancel_auto_extension"];
+/**
+ * Unregisters every entry point {@link sqlite3_auto_extension} registered.
+ *
+ * Wasm type `v()`. Signature `["sqlite3_reset_auto_extension", undefined]` from
+ * Evolu's supplement: SQLite binds the auto-extension functions by hand to
+ * manage the JavaScript functions it converts.
+ *
+ * See https://sqlite.org/c3ref/reset_auto_extension.html.
+ */
+export declare const sqlite3_reset_auto_extension: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_reset_auto_extension"];
+/**
+ * Writes N pseudo-random bytes to P. A call with N below 1 or a NULL P writes
+ * nothing and makes the next call reseed from the default VFS's xRandomness.
+ *
+ * Wasm type `v(ii)`. Signature `["sqlite3_randomness", undefined, "int", "*"]`
+ * from Evolu's supplement: SQLite binds it by hand to fill typed arrays.
+ *
+ * See https://sqlite.org/c3ref/randomness.html.
+ */
+export declare const sqlite3_randomness: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_randomness"];
+/**
+ * Returns 1 when UTF-8 SQL text ends with a complete statement, a final
+ * semicolon token that does not end inside a CREATE TRIGGER body, and 0
+ * otherwise. It tokenizes without parsing, so it does not detect invalid SQL.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_complete", "int", "string:flexible"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/complete.html.
+ */
+export declare const sqlite3_complete: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_complete"];
+/**
+ * Returns the number of distinct SQL keywords the library recognizes, which
+ * depends on compile-time options.
+ *
+ * Wasm type `i()`. Signature `["sqlite3_keyword_count", "int"]` from SQLite's
+ * table.
+ *
+ * See https://sqlite.org/c3ref/keyword_check.html.
+ */
+export declare const sqlite3_keyword_count: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_keyword_count"];
+/**
+ * Writes the address and byte length of the 0-based index-th SQL keyword, UTF-8
+ * without a NUL terminator in static memory, and returns SQLITE_ERROR when the
+ * index is out of range. Both output pointers must be valid.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_keyword_name", "int", "int", "**",
+ * "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/keyword_check.html.
+ */
+export declare const sqlite3_keyword_name: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_keyword_name"];
+/**
+ * Returns non-zero if the nName bytes of UTF-8 at zName, which need no NUL
+ * terminator, are an SQL keyword in any letter case, and 0 otherwise.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_keyword_check", "int", "string",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/keyword_check.html.
+ */
+export declare const sqlite3_keyword_check: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_keyword_check"];
+/**
+ * Returns 0 when zStr matches the GLOB pattern zGlob, case-sensitively as SQL's
+ * GLOB operator does, and non-zero otherwise.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_strglob", "int", "string", "string"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/strglob.html.
+ */
+export declare const sqlite3_strglob: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_strglob"];
+/**
+ * Returns 0 when zStr matches the LIKE pattern zGlob with escape character
+ * cEsc, or none for 0, and non-zero otherwise. Like SQL's LIKE operator, it
+ * folds only ASCII case.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_strlike", "int", "string", "string",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/strlike.html.
+ */
+export declare const sqlite3_strlike: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_strlike"];
+/**
+ * Compares two UTF-8 strings, folding only ASCII case as SQLite does for
+ * identifiers, and returns 0 when they are equal or a negative or positive
+ * number that orders them.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_stricmp", "int", "string", "string"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/stricmp.html.
+ */
+export declare const sqlite3_stricmp: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_stricmp"];
+/**
+ * Compares at most N bytes of two UTF-8 strings, folding only ASCII case as
+ * SQLite does for identifiers, and returns 0 when they are equal or a negative
+ * or positive number that orders them.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_strnicmp", "int", "string",
+ * "string", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/stricmp.html.
+ */
+export declare const sqlite3_strnicmp: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_strnicmp"];
+/**
+ * Allocates at least byteLength bytes, returning NULL when out of memory or
+ * when byteLength is zero or negative.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_malloc", "*", "int"]` from SQLite's
+ * table.
+ *
+ * See https://sqlite.org/c3ref/free.html.
+ */
+export declare const sqlite3_malloc: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_malloc"];
+/**
+ * Allocates memory like {@link sqlite3_malloc} with a 64-bit size, returning
+ * NULL when out of memory or for zero bytes.
+ *
+ * Wasm type `i(j)`. Signature `["sqlite3_malloc64", "*", "i64"]` from SQLite's
+ * table.
+ *
+ * See https://sqlite.org/c3ref/free.html.
+ */
+export declare const sqlite3_malloc64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_malloc64"];
+/**
+ * Resizes memory from {@link sqlite3_malloc}, keeping its leading bytes, and
+ * returns the new address, after which the old one is invalid. A NULL pointer
+ * allocates, a size of 0 or less frees and returns NULL, and when out of memory
+ * it returns NULL and leaves the old allocation intact.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_realloc", "*", "*", "int"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/free.html.
+ */
+export declare const sqlite3_realloc: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_realloc"];
+/**
+ * Resizes memory from {@link sqlite3_malloc}, moving its contents to the
+ * returned address; NULL memory allocates, and a zero size frees it and returns
+ * NULL. When out of memory it returns NULL and leaves the old memory
+ * allocated.
+ *
+ * Wasm type `i(ij)`. Signature `["sqlite3_realloc64", "*", "*", "i64"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/free.html.
+ */
+export declare const sqlite3_realloc64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_realloc64"];
+/**
+ * Returns the usable byte size of memory from {@link sqlite3_malloc},
+ * {@link sqlite3_realloc} or their 64-bit variants, which can exceed the
+ * requested size, or 0 for NULL.
+ *
+ * Wasm type `j(i)`. Signature `["sqlite3_msize", "i64", "*"]` from SQLite's
+ * table.
+ *
+ * See https://sqlite.org/c3ref/free.html.
+ */
+export declare const sqlite3_msize: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_msize"];
+/**
+ * Frees memory from {@link sqlite3_malloc} or from a SQLite function that
+ * returns owned memory.
+ *
+ * Wasm type `v(i)`. Signature `["sqlite3_free", undefined, "*"]` from SQLite's
+ * table.
+ *
+ * See https://sqlite.org/c3ref/free.html.
+ */
+export declare const sqlite3_free: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_free"];
+/**
+ * Opens a database connection for reading and writing, creating the database
+ * when it does not exist, with the default VFS. SQLite writes a handle even
+ * when opening fails, except when out of memory, and that handle must be
+ * closed.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_open", "int", "string", "*"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/open.html.
+ */
+export declare const sqlite3_open: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_open"];
+/**
+ * Opens a database connection. SQLite writes a handle even when opening fails,
+ * except when out of memory, and that handle must be closed.
+ *
+ * Wasm type `i(iiii)`. Signature `["sqlite3_open_v2", "int", "string", "*",
+ * "int", "string"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/open.html.
+ */
+export declare const sqlite3_open_v2: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_open_v2"];
+/**
+ * Closes a connection. With unfinalized statements the close is deferred and
+ * the connection keeps its files open.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_close_v2", "int", "sqlite3*"]` from
+ * Evolu's supplement: SQLite binds it by hand to release JavaScript callbacks
+ * first.
+ *
+ * See https://sqlite.org/c3ref/close.html.
+ */
+export declare const sqlite3_close_v2: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_close_v2"];
+/**
+ * Returns the absolute filename of a schema of the connection, valid until the
+ * schema is detached or the connection closes, or NULL or an empty string for a
+ * temporary or in-memory database or an unknown schema. A non-NULL result can
+ * be passed to the `sqlite3_uri_*` functions.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_db_filename", "string", "sqlite3*",
+ * "string"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/db_filename.html.
+ */
+export declare const sqlite3_db_filename: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_db_filename"];
+/**
+ * Returns the schema name of the connection's N-th database, where 0 is main
+ * and 1 is temp, or NULL when N is out of range. SQLite owns the string, which
+ * any schema change, such as ATTACH, DETACH, {@link sqlite3_serialize} or
+ * {@link sqlite3_deserialize}, can free.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_db_name", "string", "sqlite3*",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/db_name.html.
+ */
+export declare const sqlite3_db_name: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_db_name"];
+/**
+ * Returns 1 if a schema of the connection is read-only, 0 if it is read/write,
+ * or -1 when no schema has that name.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_db_readonly", "int", "sqlite3*",
+ * "string"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/db_readonly.html.
+ */
+export declare const sqlite3_db_readonly: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_db_readonly"];
+/**
+ * Returns a schema's transaction state, SQLITE_TXN_NONE, SQLITE_TXN_READ or
+ * SQLITE_TXN_WRITE, the highest across all schemas for NULL, or -1 for an
+ * unknown schema.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_txn_state", "int", "sqlite3*",
+ * "string"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/txn_state.html.
+ */
+export declare const sqlite3_txn_state: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_txn_state"];
+/**
+ * Returns 0 from BEGIN until the COMMIT or ROLLBACK that ends the transaction,
+ * and non-zero otherwise. It is the only way to tell whether SQLite rolled back
+ * a transaction automatically after an error such as SQLITE_FULL or
+ * SQLITE_BUSY.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_get_autocommit", "int", "sqlite3*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/get_autocommit.html.
+ */
+export declare const sqlite3_get_autocommit: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_get_autocommit"];
+/**
+ * Sets a run-time limit of the connection and returns its prior value; a
+ * negative newVal only reads it, and a value above the compile-time maximum is
+ * lowered to that maximum.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_limit", "int", "sqlite3*", "int",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/limit.html.
+ */
+export declare const sqlite3_limit: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_limit"];
+/**
+ * Sets the connection's only busy handler, replacing any other, including the
+ * one {@link sqlite3_busy_timeout} sets, or removes it for NULL so a lock fails
+ * with SQLITE_BUSY at once. SQLite calls it with pArg and the number of earlier
+ * calls for the same lock and retries while it returns non-zero; it must not
+ * modify the connection.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_busy_handler", "int", "sqlite3*",
+ * "funcptr:i(pi)", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/busy_handler.html.
+ */
+export declare const sqlite3_busy_handler: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_busy_handler"];
+/**
+ * Sets a busy handler that sleeps and retries until at least ms milliseconds
+ * have passed, replacing any other busy handler; ms of zero or less removes all
+ * busy handlers.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_busy_timeout", "int", "sqlite3*",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/busy_timeout.html.
+ */
+export declare const sqlite3_busy_timeout: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_busy_timeout"];
+/**
+ * Stops the connection's running statements, and statements started before they
+ * all finish, at their earliest opportunity with SQLITE_INTERRUPT; an
+ * interrupted write in an explicit transaction rolls the transaction back. With
+ * no running statement it does nothing.
+ *
+ * Wasm type `v(i)`. Signature `["sqlite3_interrupt", undefined, "sqlite3*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/interrupt.html.
+ */
+export declare const sqlite3_interrupt: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_interrupt"];
+/**
+ * Returns 1 while an {@link sqlite3_interrupt} is in effect for the connection,
+ * and 0 otherwise.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_is_interrupted", "int", "sqlite3*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/interrupt.html.
+ */
+export declare const sqlite3_is_interrupted: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_is_interrupted"];
+/**
+ * Enables extended result codes for the connection when onoff is non-zero and
+ * disables them otherwise. They are disabled by default, and
+ * {@link sqlite3_extended_errcode} returns them regardless.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_extended_result_codes", "int",
+ * "sqlite3*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/extended_result_codes.html.
+ */
+export declare const sqlite3_extended_result_codes: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_extended_result_codes"];
+/**
+ * Calls the xFileControl method of a schema's file, main for a NULL zDbName,
+ * with an opcode and its argument and returns its result; the core handles a
+ * few opcodes, such as SQLITE_FCNTL_FILE_POINTER, itself. An unknown schema
+ * returns SQLITE_ERROR without recording it for {@link sqlite3_errcode}.
+ *
+ * Wasm type `i(iiii)`. Signature `["sqlite3_file_control", "int", "sqlite3*",
+ * "string", "int", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/file_control.html.
+ */
+export declare const sqlite3_file_control: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_file_control"];
+/**
+ * Writes a table column's declared type, collation sequence and NOT NULL,
+ * PRIMARY KEY and AUTOINCREMENT flags through the non-NULL output pointers,
+ * failing for a missing column or a view; a NULL column name only checks that
+ * the table exists. The returned strings stay valid only until the next SQLite
+ * call.
+ *
+ * Wasm type `i(iiiiiiiii)`. Signature `["sqlite3_table_column_metadata", "int",
+ * "sqlite3*", "string", "string", "string", "**", "**", "*", "*", "*"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/table_column_metadata.html.
+ */
+export declare const sqlite3_table_column_metadata: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_table_column_metadata"];
+/**
+ * Writes the current and highest values of a connection status counter to pCur
+ * and pHiwtr, resetting the highest to the current value when resetFlg is
+ * non-zero. Values above the int range are truncated;
+ * {@link sqlite3_db_status64} returns them in full.
+ *
+ * Wasm type `i(iiiii)`. Signature `["sqlite3_db_status", "int", "sqlite3*",
+ * "int", "*", "*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/db_status.html.
+ */
+export declare const sqlite3_db_status: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_db_status"];
+/**
+ * Reads a connection's SQLITE_DBSTATUS_* counter into the sqlite3_int64 at pCur
+ * and its highwater mark into the sqlite3_int64 at pHiwtr, 8 bytes each,
+ * resetting the mark to the current value when resetFlg is non-zero.
+ *
+ * Wasm type `i(iiiii)`. Signature `["sqlite3_db_status64", "int", "sqlite3*",
+ * "int", "*", "*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/db_status.html.
+ */
+export declare const sqlite3_db_status64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_db_status64"];
+/**
+ * Returns the rowid of the connection's most recent successful INSERT into a
+ * rowid table, or 0 if there was none. Inside a trigger it returns the
+ * trigger's insert until the trigger ends, and a failed INSERT leaves it
+ * unchanged.
+ *
+ * Wasm type `j(i)`. Signature `["sqlite3_last_insert_rowid", "i64",
+ * "sqlite3*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/last_insert_rowid.html.
+ */
+export declare const sqlite3_last_insert_rowid: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_last_insert_rowid"];
+/**
+ * Sets the value {@link sqlite3_last_insert_rowid} returns for the connection
+ * without inserting a row.
+ *
+ * Wasm type `v(ij)`. Signature `["sqlite3_set_last_insert_rowid", undefined,
+ * "sqlite3*", "i64"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/set_last_insert_rowid.html.
+ */
+export declare const sqlite3_set_last_insert_rowid: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_set_last_insert_rowid"];
+/**
+ * Returns the rows changed by the connection's most recently completed INSERT,
+ * UPDATE or DELETE, without changes by triggers, foreign key actions or
+ * REPLACE; other statements leave it unchanged, except a DROP TABLE that, with
+ * foreign keys on, first deletes the rows of a table that foreign keys
+ * reference. The result is undefined above the int range, which
+ * {@link sqlite3_changes64} covers.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_changes", "int", "sqlite3*"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/changes.html.
+ */
+export declare const sqlite3_changes: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_changes"];
+/**
+ * Returns the rows changed by the connection's most recently completed INSERT,
+ * UPDATE or DELETE, without changes by triggers, foreign key actions or
+ * REPLACE; other statements leave it unchanged, except a DROP TABLE that, with
+ * foreign keys on, first deletes the rows of a table that foreign keys
+ * reference.
+ *
+ * Wasm type `j(i)`. Signature `["sqlite3_changes64", "i64", "sqlite3*"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/changes.html.
+ */
+export declare const sqlite3_changes64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_changes64"];
+/**
+ * Returns the rows inserted, updated or deleted by the connection's completed
+ * statements since it opened, including those of triggers and foreign key
+ * actions. The result is undefined beyond the int range, which
+ * {@link sqlite3_total_changes64} avoids.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_total_changes", "int", "sqlite3*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/total_changes.html.
+ */
+export declare const sqlite3_total_changes: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_total_changes"];
+/**
+ * Returns the number of rows changed by INSERT, UPDATE and DELETE statements on
+ * the connection since it opened, counting trigger and foreign key action
+ * changes but not REPLACE conflict deletions. Other connections do not change
+ * it, and other statements do not either, except a DROP TABLE that, with
+ * foreign keys on, first deletes the rows of a table that foreign keys
+ * reference.
+ *
+ * Wasm type `j(i)`. Signature `["sqlite3_total_changes64", "i64", "sqlite3*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/total_changes.html.
+ */
+export declare const sqlite3_total_changes64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_total_changes64"];
+/**
+ * Runs zero or more semicolon-separated UTF-8 SQL statements, stopping at the
+ * first error, and calls the callback, unless NULL, with pArg for each result
+ * row; a non-zero callback result stops with SQLITE_ABORT. Unless errmsg is
+ * NULL, it receives NULL on success or an error message the caller frees with
+ * {@link sqlite3_free}.
+ *
+ * Wasm type `i(iiiii)`. Signature `["sqlite3_exec", "int", "sqlite3*",
+ * "string:flexible", "funcptr:i(pipp)", "*", "**"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/exec.html.
+ */
+export declare const sqlite3_exec: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_exec"];
+/**
+ * Copies a schema, NULL meaning main, into memory from {@link sqlite3_malloc64}
+ * that the caller frees, writing its byte size as an 8-byte sqlite3_int64 to
+ * piSize unless NULL. An empty database first gets its first page from an empty
+ * write transaction. Pages are read through the pager, so an encrypted database
+ * comes out decrypted, and a page that fails to read comes out zero-filled.
+ * Returns NULL when out of memory, for an unknown schema or a database without
+ * pages, and with SQLITE_SERIALIZE_NOCOPY returns SQLite's own buffer of a
+ * deserialized database, or NULL, instead of a copy, which the caller must
+ * neither free nor modify. Only a call whose mFlags is 0 returns memory
+ * {@link sqlite3_free} accepts.
+ *
+ * Wasm type `i(iiii)`. Signature `["sqlite3_serialize", "*", "sqlite3*",
+ * "string", "*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/serialize.html.
+ */
+export declare const sqlite3_serialize: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_serialize"];
+/**
+ * Reopens a schema, main for NULL, as an in-memory database over the first szDb
+ * bytes of a szBuf-byte buffer, which must stay valid and unmodified until the
+ * connection closes. With SQLITE_DESERIALIZE_FREEONCLOSE, SQLite takes
+ * ownership of the {@link sqlite3_malloc}'d buffer and frees it, even when
+ * deserializing fails.
+ *
+ * Wasm type `i(iiijji)`. Signature `["sqlite3_deserialize", "int", "sqlite3*",
+ * "string", "*", "i64", "i64", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/deserialize.html.
+ */
+export declare const sqlite3_deserialize: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_deserialize"];
+/**
+ * Returns the result code of the connection's most recent API call if that call
+ * failed, as a primary code unless extended result codes are enabled.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_errcode", "int", "sqlite3*"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/errcode.html.
+ */
+export declare const sqlite3_errcode: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_errcode"];
+/**
+ * Returns the connection's most recent extended result code.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_extended_errcode", "int", "sqlite3*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/errcode.html.
+ */
+export declare const sqlite3_extended_errcode: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_extended_errcode"];
+/**
+ * Returns the English message of the connection's most recent error, or NULL
+ * when none is available. SQLite owns the string, which the next call on the
+ * connection can overwrite or free.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_errmsg", "string", "sqlite3*"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/errcode.html.
+ */
+export declare const sqlite3_errmsg: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_errmsg"];
+/**
+ * Returns the English description of a result code, or NULL when none is
+ * available. The string is static and must not be freed.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_errstr", "string", "int"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/errcode.html.
+ */
+export declare const sqlite3_errstr: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_errstr"];
+/**
+ * Returns the byte offset in the SQL of the most recent error, or -1.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_error_offset", "int", "sqlite3*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/errcode.html.
+ */
+export declare const sqlite3_error_offset: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_error_offset"];
+/**
+ * Sets the error code and a copy of zErrMsg, or the code's default message for
+ * NULL, that {@link sqlite3_errcode} and {@link sqlite3_errmsg} report for a
+ * connection until SQLite or another call replaces them.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_set_errmsg", "int", "sqlite3*",
+ * "int", "string"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/set_errmsg.html.
+ */
+export declare const sqlite3_set_errmsg: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_set_errmsg"];
+/**
+ * Sets the connection's commit callback, replacing the previous one, or removes
+ * it for NULL, and returns the previous call's pArg, NULL for the first call.
+ * SQLite calls it with pArg before each commit and turns the commit into a
+ * rollback when it returns non-zero; it must not modify the connection.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_commit_hook", "void*", "sqlite3*",
+ * "funcptr:i(p)", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/commit_hook.html.
+ */
+export declare const sqlite3_commit_hook: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_commit_hook"];
+/**
+ * Registers the callback SQLite calls with pArg whenever a transaction rolls
+ * back, except when closing the connection, replacing the previous one; NULL
+ * removes it. Returns the previous pArg or NULL; the callback must not use the
+ * connection, not even to prepare or step a statement.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_rollback_hook", "void*", "sqlite3*",
+ * "funcptr:v(p)", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/commit_hook.html.
+ */
+export declare const sqlite3_rollback_hook: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_rollback_hook"];
+/**
+ * Registers the connection's callback for each row inserted, updated or deleted
+ * in a rowid table, replacing the previous one or removing it for NULL, and
+ * returns the previous pArg or NULL. The callback must not modify the
+ * connection and does not fire for WITHOUT ROWID tables, REPLACE conflict
+ * deletions or the truncate optimization.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_update_hook", "*", "sqlite3*",
+ * "funcptr:v(pippj)", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/update_hook.html.
+ */
+export declare const sqlite3_update_hook: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_update_hook"];
+/**
+ * Registers the connection's one trace callback for the SQLITE_TRACE_* events
+ * in uMask, replacing any previous one; a NULL callback or a zero mask disables
+ * tracing. The callback receives the event code, pCtx and two event-specific
+ * pointers, and should return 0.
+ *
+ * Wasm type `i(iiii)`. Signature `["sqlite3_trace_v2", "int", "sqlite3*",
+ * "int", "funcptr:i(ippp)", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/trace_v2.html.
+ */
+export declare const sqlite3_trace_v2: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_trace_v2"];
+/**
+ * Sets the connection's callback for an undefined collation sequence, replacing
+ * the previous one. SQLite calls it with pArg, the connection, the preferred
+ * text encoding and the UTF-8 collation name, and the callback should register
+ * that collation.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_collation_needed", "int",
+ * "sqlite3*", "*", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/collation_needed.html.
+ */
+export declare const sqlite3_collation_needed: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_collation_needed"];
+/**
+ * Compiles the first statement of UTF-8 SQL as {@link sqlite3_prepare_v3} does
+ * with no flags, reading at most nByte bytes or up to a NUL when nByte is
+ * negative, and writes the statement to `*ppStmt` and the address of the
+ * uncompiled rest to `*pzTail`. `*ppStmt` is NULL on error and for SQL without
+ * a statement, such as only a comment; the caller finalizes a non-NULL one.
+ *
+ * Wasm type `i(iiiii)`. Signature `["sqlite3_prepare_v2", "int", "sqlite3*",
+ * "*", "int", "**", "**"]` from Evolu's supplement: SQLite binds it by hand to
+ * accept JavaScript strings.
+ *
+ * See https://sqlite.org/c3ref/prepare.html.
+ */
+export declare const sqlite3_prepare_v2: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_prepare_v2"];
+/**
+ * Compiles the first statement of UTF-8 SQL, reading at most nByte bytes or up
+ * to a NUL when nByte is negative, and writes the statement to `*ppStmt` and
+ * the address of the uncompiled rest to `*pzTail`. `*ppStmt` is NULL on error
+ * and for SQL without a statement, such as only a comment; the caller finalizes
+ * a non-NULL one.
+ *
+ * Wasm type `i(iiiiii)`. Signature `["sqlite3_prepare_v3", "int", "sqlite3*",
+ * "*", "int", "int", "**", "**"]` from Evolu's supplement: SQLite binds it by
+ * hand to accept JavaScript strings.
+ *
+ * See https://sqlite.org/c3ref/prepare.html.
+ */
+export declare const sqlite3_prepare_v3: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_prepare_v3"];
+/**
+ * Evaluates a statement one step, returning SQLITE_ROW, SQLITE_DONE or an
+ * error.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_step", "int", "sqlite3_stmt*"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/step.html.
+ */
+export declare const sqlite3_step: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_step"];
+/**
+ * Resets a statement so it can run again, keeping its bindings. It returns the
+ * error of a failed most recent step, and can fail on its own, such as with
+ * SQLITE_BUSY when an INSERT with RETURNING stepped only once cannot commit.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_reset", "int", "sqlite3_stmt*"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/reset.html.
+ */
+export declare const sqlite3_reset: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_reset"];
+/**
+ * Destroys a prepared statement and returns the error of its most recent
+ * evaluation if that failed, otherwise SQLITE_OK; NULL is a harmless no-op.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_finalize", "int", "sqlite3_stmt*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/finalize.html.
+ */
+export declare const sqlite3_finalize: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_finalize"];
+/**
+ * Returns the connection's first prepared statement for a NULL pStmt, otherwise
+ * the one after pStmt, or NULL when there is none.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_next_stmt", "sqlite3_stmt*",
+ * "sqlite3*", "sqlite3_stmt*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/next_stmt.html.
+ */
+export declare const sqlite3_next_stmt: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_next_stmt"];
+/**
+ * Returns the connection a prepared statement belongs to.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_db_handle", "sqlite3*",
+ * "sqlite3_stmt*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/db_handle.html.
+ */
+export declare const sqlite3_db_handle: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_db_handle"];
+/**
+ * Returns the SQL text a statement was prepared from, which SQLite frees when
+ * the statement is finalized, or NULL for a statement from the legacy
+ * sqlite3_prepare, which this build does not export.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_sql", "string", "sqlite3_stmt*"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/expanded_sql.html.
+ */
+export declare const sqlite3_sql: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_sql"];
+/**
+ * Returns the statement's SQL with bound parameters expanded as literals, in
+ * memory the caller frees with {@link sqlite3_free}, or NULL when out of memory,
+ * above SQLITE_LIMIT_LENGTH, or when built with SQLITE_OMIT_TRACE.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_expanded_sql", "string",
+ * "sqlite3_stmt*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/expanded_sql.html.
+ */
+export declare const sqlite3_expanded_sql: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_expanded_sql"];
+/**
+ * Returns non-zero when a statement has been stepped but has neither returned
+ * SQLITE_DONE nor been reset, and 0 for NULL.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_stmt_busy", "int", "sqlite3_stmt*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/stmt_busy.html.
+ */
+export declare const sqlite3_stmt_busy: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_stmt_busy"];
+/**
+ * Returns non-zero when a statement cannot directly change the database file,
+ * though application-defined functions or virtual tables it calls still might.
+ * Transaction control, ATTACH and DETACH count as read-only; BEGIN IMMEDIATE,
+ * BEGIN EXCLUSIVE and any statement that might write do not.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_stmt_readonly", "int",
+ * "sqlite3_stmt*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/stmt_readonly.html.
+ */
+export declare const sqlite3_stmt_readonly: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_stmt_readonly"];
+/**
+ * Makes a statement behave as if its SQL began with EXPLAIN (eMode 1), EXPLAIN
+ * QUERY PLAN (2) or neither (0), possibly re-preparing it. It fails while the
+ * statement is active, so reset it first.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_stmt_explain", "int",
+ * "sqlite3_stmt*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/stmt_explain.html.
+ */
+export declare const sqlite3_stmt_explain: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_stmt_explain"];
+/**
+ * Returns 1 for an EXPLAIN statement, 2 for EXPLAIN QUERY PLAN, and 0 for an
+ * ordinary statement or NULL.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_stmt_isexplain", "int",
+ * "sqlite3_stmt*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/stmt_isexplain.html.
+ */
+export declare const sqlite3_stmt_isexplain: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_stmt_isexplain"];
+/**
+ * Returns one of a statement's SQLITE_STMTSTATUS_* counters, and resets it to 0
+ * afterwards when resetFlg is non-zero.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_stmt_status", "int",
+ * "sqlite3_stmt*", "int", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/stmt_status.html.
+ */
+export declare const sqlite3_stmt_status: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_stmt_status"];
+/**
+ * Returns the index of a statement's largest SQL parameter, which is the number
+ * of parameters unless `?NNN` parameters leave gaps.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_bind_parameter_count", "int",
+ * "sqlite3_stmt*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/bind_parameter_count.html.
+ */
+export declare const sqlite3_bind_parameter_count: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_parameter_count"];
+/**
+ * Returns the 1-based index of the SQL parameter with a UTF-8 name that
+ * includes its prefix, such as `:name`, or 0 when no parameter matches.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_bind_parameter_index", "int",
+ * "sqlite3_stmt*", "string"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/bind_parameter_index.html.
+ */
+export declare const sqlite3_bind_parameter_index: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_parameter_index"];
+/**
+ * Returns the name of the SQL parameter at a 1-based index, including its
+ * prefix as in `:name` or `?NNN`, or NULL for a nameless `?` parameter or an
+ * index out of range. The statement owns the string.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_bind_parameter_name", "string",
+ * "sqlite3_stmt*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/bind_parameter_name.html.
+ */
+export declare const sqlite3_bind_parameter_name: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_parameter_name"];
+/**
+ * Binds NULL to a parameter.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_bind_null", undefined,
+ * "sqlite3_stmt*", "int"]` from SQLite's table, with the result corrected:
+ * SQLite's table declares no result, but the C function returns a result code,
+ * as the wasm type shows.
+ *
+ * See https://sqlite.org/c3ref/bind_blob.html.
+ */
+export declare const sqlite3_bind_null: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_null"];
+/**
+ * Binds a 32-bit integer to a parameter. The wasm boundary converts the number
+ * with ToInt32, so a fraction is truncated and a value outside the int32 range
+ * wraps silently.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_bind_int", "int", "sqlite3_stmt*",
+ * "int", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/bind_blob.html.
+ */
+export declare const sqlite3_bind_int: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_int"];
+/**
+ * Binds a 64-bit integer to a parameter. The wasm boundary wraps a bigint
+ * outside the int64 range silently.
+ *
+ * Wasm type `i(iij)`. Signature `["sqlite3_bind_int64", "int", "sqlite3_stmt*",
+ * "int", "i64"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/bind_blob.html.
+ */
+export declare const sqlite3_bind_int64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_int64"];
+/**
+ * Binds a double to a parameter; SQLite stores NaN as NULL.
+ *
+ * Wasm type `i(iid)`. Signature `["sqlite3_bind_double", "int",
+ * "sqlite3_stmt*", "int", "f64"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/bind_blob.html.
+ */
+export declare const sqlite3_bind_double: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_double"];
+/**
+ * Binds UTF-8 text to a parameter: n bytes, which may include NUL characters,
+ * or up to the first NUL when n is negative. A NULL address binds SQL NULL.
+ *
+ * Wasm type `i(iiiii)`. Signature `["sqlite3_bind_text", "int",
+ * "sqlite3_stmt*", "int", "*", "int", "*"]` from Evolu's supplement: SQLite
+ * binds it by hand to accept JavaScript strings and typed arrays.
+ *
+ * See https://sqlite.org/c3ref/bind_blob.html.
+ */
+export declare const sqlite3_bind_text: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_text"];
+/**
+ * Binds n bytes to a parameter; a negative n is undefined behavior. A NULL
+ * address binds SQL NULL, so an empty blob needs a non-NULL address.
+ *
+ * Wasm type `i(iiiii)`. Signature `["sqlite3_bind_blob", "int",
+ * "sqlite3_stmt*", "int", "*", "int", "*"]` from Evolu's supplement: SQLite
+ * binds it by hand to accept typed arrays.
+ *
+ * See https://sqlite.org/c3ref/bind_blob.html.
+ */
+export declare const sqlite3_bind_blob: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_blob"];
+/**
+ * Binds a blob of n zero bytes to a parameter without allocating its content; a
+ * negative n binds a zero-length blob.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_bind_zeroblob", "int",
+ * "sqlite3_stmt*", "int", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/bind_blob.html.
+ */
+export declare const sqlite3_bind_zeroblob: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_zeroblob"];
+/**
+ * Binds SQL NULL carrying pPtr tagged with the type string zPType, which only
+ * {@link sqlite3_value_pointer} with an equal type string returns. The type
+ * string should be static because SQLite keeps its address, and SQLite calls
+ * xDestructor, unless NULL, with pPtr when done, even when binding fails.
+ *
+ * Wasm type `i(iiiii)`. Signature `["sqlite3_bind_pointer", "int",
+ * "sqlite3_stmt*", "int", "*", "string:static", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/bind_blob.html.
+ */
+export declare const sqlite3_bind_pointer: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_bind_pointer"];
+/**
+ * Sets every parameter of a statement to NULL, which {@link sqlite3_reset} does
+ * not do.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_clear_bindings", "int",
+ * "sqlite3_stmt*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/clear_bindings.html.
+ */
+export declare const sqlite3_clear_bindings: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_clear_bindings"];
+/**
+ * Returns the number of result columns of a statement.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_column_count", "int",
+ * "sqlite3_stmt*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/column_count.html.
+ */
+export declare const sqlite3_column_count: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_count"];
+/**
+ * Returns the number of columns in the statement's current row, or 0 when the
+ * last step did not return SQLITE_ROW or the statement is NULL.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_data_count", "int", "sqlite3_stmt*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/data_count.html.
+ */
+export declare const sqlite3_data_count: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_data_count"];
+/**
+ * Returns the name of a result column, which is its AS alias or else
+ * unspecified, or NULL when out of memory or the index is out of range. The
+ * statement owns the string until it is finalized or re-prepared.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_column_name", "string",
+ * "sqlite3_stmt*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/column_name.html.
+ */
+export declare const sqlite3_column_name: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_name"];
+/**
+ * Returns the declared type of the table column a result column comes from, or
+ * NULL when the result column is an expression or subquery. The statement owns
+ * the string.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_column_decltype", "string",
+ * "sqlite3_stmt*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/column_decltype.html.
+ */
+export declare const sqlite3_column_decltype: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_decltype"];
+/**
+ * Returns the storage class of a result column in the current row. Read it
+ * before any other column function, which can convert the value.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_column_type", "int", "sqlite3_stmt*",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/column_blob.html.
+ */
+export declare const sqlite3_column_type: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_type"];
+/**
+ * Returns a result column of the current row as a 32-bit integer, converting
+ * other types; an integer outside the 32-bit range keeps only its low 32 bits.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_column_int", "int", "sqlite3_stmt*",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/column_blob.html.
+ */
+export declare const sqlite3_column_int: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_int"];
+/**
+ * Returns a result column of the current row as a 64-bit integer, converting
+ * other types as CAST does, and 0 for NULL.
+ *
+ * Wasm type `j(ii)`. Signature `["sqlite3_column_int64", "i64",
+ * "sqlite3_stmt*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/column_blob.html.
+ */
+export declare const sqlite3_column_int64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_int64"];
+/**
+ * Returns a result column of the current row as a double, converting other
+ * types, such as NULL to 0.0.
+ *
+ * Wasm type `d(ii)`. Signature `["sqlite3_column_double", "f64",
+ * "sqlite3_stmt*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/column_blob.html.
+ */
+export declare const sqlite3_column_double: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_double"];
+/**
+ * Returns the address of a result column as NUL-terminated UTF-8 text that can
+ * contain NUL characters, so read its length with {@link sqlite3_column_bytes}
+ * afterwards. Returns NULL for SQL NULL and when out of memory, which
+ * {@link sqlite3_errcode} tells apart; the text stays valid until the next step,
+ * reset or finalize, or a conversion by another column call.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_column_text", "*", "sqlite3_stmt*",
+ * "int"]` from Evolu's supplement: SQLite's build replaces it with a JavaScript
+ * proxy that keeps embedded NUL characters (proxy-text-apis).
+ *
+ * See https://sqlite.org/c3ref/column_blob.html.
+ */
+export declare const sqlite3_column_text: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_text"];
+/**
+ * Returns the address of a result column's bytes, or NULL for a zero-length
+ * blob, SQL NULL or out of memory; call it before {@link sqlite3_column_bytes}.
+ * The memory stays valid until a type conversion of the column or the next
+ * step, reset or finalize, and SQLite frees it.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_column_blob", "*", "sqlite3_stmt*",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/column_blob.html.
+ */
+export declare const sqlite3_column_blob: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_blob"];
+/**
+ * Returns the byte length of the text or blob the preceding column call
+ * returned.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_column_bytes", "int",
+ * "sqlite3_stmt*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/column_blob.html.
+ */
+export declare const sqlite3_column_bytes: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_bytes"];
+/**
+ * Returns a result column of the current row as an unprotected sqlite3_value,
+ * valid until the next step, reset or finalize. This build is single-threaded
+ * (SQLITE_THREADSAFE=0), so an unprotected value works wherever a protected one
+ * does, and {@link sqlite3_value_dup} copies it to outlive the row.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_column_value", "sqlite3_value*",
+ * "sqlite3_stmt*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/column_blob.html.
+ */
+export declare const sqlite3_column_value: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_column_value"];
+/**
+ * Returns a value's initial fundamental data type. Read it before the other
+ * value functions, whose conversions can change it.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_value_type", "int", "sqlite3_value*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_type: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_type"];
+/**
+ * Converts a value that looks like a number to INTEGER or FLOAT when no
+ * information is lost, and returns its resulting fundamental data type.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_value_numeric_type", "int",
+ * "sqlite3_value*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_numeric_type: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_numeric_type"];
+/**
+ * Returns a value as a 32-bit integer, converting other types as CAST does and
+ * truncating a larger integer to its low 32 bits, and 0 for NULL.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_value_int", "int", "sqlite3_value*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_int: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_int"];
+/**
+ * Returns a value as a 64-bit integer, converting other storage classes as
+ * {@link sqlite3_column_int64} does.
+ *
+ * Wasm type `j(i)`. Signature `["sqlite3_value_int64", "i64",
+ * "sqlite3_value*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_int64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_int64"];
+/**
+ * Returns a value as a double, converting other types as CAST does, and 0.0 for
+ * NULL.
+ *
+ * Wasm type `d(i)`. Signature `["sqlite3_value_double", "f64",
+ * "sqlite3_value*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_double: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_double"];
+/**
+ * Returns the address of a protected value as NUL-terminated UTF-8 text that
+ * can contain NUL characters, so read its length with
+ * {@link sqlite3_value_bytes} afterwards. Returns NULL for SQL NULL and when out
+ * of memory, and a later call that converts the value can invalidate the text.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_value_text", "*", "sqlite3_value*"]`
+ * from Evolu's supplement: SQLite's build replaces it with a JavaScript proxy
+ * that keeps embedded NUL characters (proxy-text-apis).
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_text: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_text"];
+/**
+ * Returns the address of a value's bytes, rendering a number as text, or NULL
+ * for a zero-length value or SQL NULL. Call it before
+ * {@link sqlite3_value_bytes}; a later text conversion invalidates the address.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_value_blob", "*", "sqlite3_value*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_blob: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_blob"];
+/**
+ * Returns the byte length of the blob or UTF-8 text the preceding
+ * {@link sqlite3_value_blob} or {@link sqlite3_value_text} call returned, without
+ * the NUL terminator; 0 for NULL.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_value_bytes", "int",
+ * "sqlite3_value*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_bytes: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_bytes"];
+/**
+ * Returns the pointer {@link sqlite3_bind_pointer} or
+ * {@link sqlite3_result_pointer} attached to a value under a type name equal to
+ * zPType by strcmp, and NULL otherwise.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_value_pointer", "*",
+ * "sqlite3_value*", "string:static"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_pointer: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_pointer"];
+/**
+ * Returns the subtype of an application-defined function argument, as
+ * {@link sqlite3_result_subtype} set it, or 0. The reading function should be
+ * registered with SQLITE_SUBTYPE, or it might get 0 in corner cases.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_value_subtype", "int",
+ * "sqlite3_value*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_subtype.html.
+ */
+export declare const sqlite3_value_subtype: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_subtype"];
+/**
+ * Returns non-zero when a value came from a bound parameter rather than a
+ * literal, a column or an expression.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_value_frombind", "int",
+ * "sqlite3_value*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_frombind: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_frombind"];
+/**
+ * Within a virtual table's xUpdate, returns non-zero when the value's column is
+ * unchanged by the UPDATE because xColumn set no result; such a value otherwise
+ * looks like NULL. Anywhere else the result is meaningless.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_value_nochange", "int",
+ * "sqlite3_value*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_blob.html.
+ */
+export declare const sqlite3_value_nochange: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_nochange"];
+/**
+ * Copies a value into a protected value the caller frees with
+ * {@link sqlite3_value_free}. Returns NULL for NULL or when out of memory, and a
+ * pointer value copies as SQL NULL.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_value_dup", "sqlite3_value*",
+ * "sqlite3_value*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_dup.html.
+ */
+export declare const sqlite3_value_dup: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_dup"];
+/**
+ * Frees a value from {@link sqlite3_value_dup}; NULL is a no-op.
+ *
+ * Wasm type `v(i)`. Signature `["sqlite3_value_free", undefined,
+ * "sqlite3_value*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/value_dup.html.
+ */
+export declare const sqlite3_value_free: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_value_free"];
+/**
+ * Adds, redefines or, with xFunc, xStep and xFinal all NULL, removes an SQL
+ * function of the connection: xFunc implements a scalar function, xStep with
+ * xFinal an aggregate. nArg is the argument count or -1 for any, and eTextRep
+ * the preferred text encoding, optionally with flags such as
+ * SQLITE_DETERMINISTIC and SQLITE_DIRECTONLY.
+ *
+ * Wasm type `i(iiiiiiii)`. Signature `["sqlite3_create_function", "int",
+ * "sqlite3*", "string", "int", "int", "*", "funcptr:v(pip)", "funcptr:v(pip)",
+ * "funcptr:v(p)"]` from Evolu's supplement: SQLite binds it by hand to accept
+ * JavaScript functions as callbacks.
+ *
+ * See https://sqlite.org/c3ref/create_function.html.
+ */
+export declare const sqlite3_create_function: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_create_function"];
+/**
+ * Works like {@link sqlite3_create_function}, and SQLite calls a non-NULL
+ * xDestroy with pApp when the function is redefined or removed, when the
+ * connection closes, and when this call fails.
+ *
+ * Wasm type `i(iiiiiiiii)`. Signature `["sqlite3_create_function_v2", "int",
+ * "sqlite3*", "string", "int", "int", "*", "funcptr:v(pip)", "funcptr:v(pip)",
+ * "funcptr:v(p)", "funcptr:v(p)"]` from Evolu's supplement: SQLite binds it by
+ * hand to accept JavaScript functions as callbacks.
+ *
+ * See https://sqlite.org/c3ref/create_function.html.
+ */
+export declare const sqlite3_create_function_v2: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_create_function_v2"];
+/**
+ * Ensures a global SQL function with this name and argument count exists,
+ * creating a placeholder that raises an error when called, so a virtual table's
+ * xFindFunction can overload it.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_overload_function", "int",
+ * "sqlite3*", "string", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/overload_function.html.
+ */
+export declare const sqlite3_overload_function: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_overload_function"];
+/**
+ * Adds, replaces or, with a NULL xCompare, removes a collation named zName for
+ * text in the eTextRep encoding. `xCompare(pArg, n1, s1, n2, s2)` compares two
+ * strings of the given byte lengths and returns a negative number, zero or a
+ * positive number; SQLite behavior is undefined when the comparison is
+ * inconsistent.
+ *
+ * Wasm type `i(iiiii)`. Signature `["sqlite3_create_collation", "int",
+ * "sqlite3*", "string", "int", "*", "funcptr:i(pipip)"]` from Evolu's
+ * supplement: SQLite binds it by hand to accept JavaScript functions as
+ * callbacks.
+ *
+ * See https://sqlite.org/c3ref/create_collation.html.
+ */
+export declare const sqlite3_create_collation: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_create_collation"];
+/**
+ * Works like {@link sqlite3_create_collation}, and SQLite calls a non-NULL
+ * xDestroy with pArg when the collation is replaced or the connection closes.
+ * Unlike other SQLite functions, it does not call xDestroy when this call
+ * fails, so the caller then disposes of pArg.
+ *
+ * Wasm type `i(iiiiii)`. Signature `["sqlite3_create_collation_v2", "int",
+ * "sqlite3*", "string", "int", "*", "funcptr:i(pipip)", "funcptr:v(p)"]` from
+ * Evolu's supplement: SQLite binds it by hand to accept JavaScript functions as
+ * callbacks.
+ *
+ * See https://sqlite.org/c3ref/create_collation.html.
+ */
+export declare const sqlite3_create_collation_v2: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_create_collation_v2"];
+/**
+ * Returns the user data pointer the running application-defined function was
+ * registered with.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_user_data", "void*",
+ * "sqlite3_context*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/user_data.html.
+ */
+export declare const sqlite3_user_data: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_user_data"];
+/**
+ * Returns the connection that registered the application-defined function being
+ * called.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_context_db_handle", "sqlite3*",
+ * "sqlite3_context*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/context_db_handle.html.
+ */
+export declare const sqlite3_context_db_handle: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_context_db_handle"];
+/**
+ * Returns the state memory of the current aggregate function instance: the
+ * first call allocates nBytes of zeroed memory, later calls return the same
+ * buffer, and SQLite frees it when the aggregate concludes. Returns NULL when
+ * the first call passes nBytes of zero or less or runs out of memory.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_aggregate_context", "void*",
+ * "sqlite3_context*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/aggregate_context.html.
+ */
+export declare const sqlite3_aggregate_context: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_aggregate_context"];
+/**
+ * Returns the auxiliary data {@link sqlite3_set_auxdata} associated with the
+ * 0-based N-th argument of the current function call, or NULL when there is
+ * none or SQLite discarded it.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_get_auxdata", "*",
+ * "sqlite3_context*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/get_auxdata.html.
+ */
+export declare const sqlite3_get_auxdata: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_get_auxdata"];
+/**
+ * Attaches pAux to the N-th argument of the running application-defined
+ * function, where {@link sqlite3_get_auxdata} finds it while the argument stays
+ * the same. SQLite may discard it at any time, even before this call returns,
+ * calling a non-NULL xDelete with pAux, so pAux must not be used afterwards.
+ *
+ * Wasm type `v(iiii)`. Signature `["sqlite3_set_auxdata", undefined,
+ * "sqlite3_context*", "int", "*", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/get_auxdata.html.
+ */
+export declare const sqlite3_set_auxdata: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_set_auxdata"];
+/**
+ * Sets an application-defined function's result to NULL.
+ *
+ * Wasm type `v(i)`. Signature `["sqlite3_result_null", undefined,
+ * "sqlite3_context*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_null: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_null"];
+/**
+ * Sets an application-defined function's result to a 32-bit integer. The wasm
+ * boundary converts the number with ToInt32, so a fraction is truncated and a
+ * value outside the int32 range wraps silently.
+ *
+ * Wasm type `v(ii)`. Signature `["sqlite3_result_int", undefined,
+ * "sqlite3_context*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_int: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_int"];
+/**
+ * Sets an application-defined function's result to a 64-bit integer. The wasm
+ * boundary wraps a bigint outside the int64 range silently.
+ *
+ * Wasm type `v(ij)`. Signature `["sqlite3_result_int64", undefined, "*",
+ * "i64"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_int64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_int64"];
+/**
+ * Sets an application-defined function's result to a double; SQLite stores NaN
+ * as NULL.
+ *
+ * Wasm type `v(id)`. Signature `["sqlite3_result_double", undefined,
+ * "sqlite3_context*", "f64"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_double: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_double"];
+/**
+ * Sets an application-defined function's result to UTF-8 text of n bytes, or up
+ * to its NUL terminator when n is negative. A NULL address sets SQL NULL, as
+ * for {@link sqlite3_bind_text}.
+ *
+ * Wasm type `v(iiii)`. Signature `["sqlite3_result_text", undefined,
+ * "sqlite3_context*", "string", "int", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_text: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_text"];
+/**
+ * Sets an application-defined function's result to n bytes. A NULL address sets
+ * SQL NULL, as for {@link sqlite3_bind_blob}, so an empty blob needs a non-NULL
+ * address or {@link sqlite3_result_zeroblob}.
+ *
+ * Wasm type `v(iiii)`. Signature `["sqlite3_result_blob", undefined,
+ * "sqlite3_context*", "*", "int", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_blob: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_blob"];
+/**
+ * Sets an application-defined function's result to a blob of n zero bytes, 0
+ * for a negative n. A size beyond SQLITE_LIMIT_LENGTH makes the function fail
+ * with SQLITE_TOOBIG.
+ *
+ * Wasm type `v(ii)`. Signature `["sqlite3_result_zeroblob", undefined,
+ * "sqlite3_context*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_zeroblob: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_zeroblob"];
+/**
+ * Sets an application-defined function's result to a blob of n zero bytes.
+ * Returns SQLITE_TOOBIG, and makes the function fail with that error, when n
+ * exceeds the connection's length limit.
+ *
+ * Wasm type `i(ij)`. Signature `["sqlite3_result_zeroblob64", "int", "*",
+ * "i64"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_zeroblob64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_zeroblob64"];
+/**
+ * Sets an application-defined function's result to an SQL NULL carrying pPtr,
+ * which {@link sqlite3_value_pointer} returns for an equal type name. SQLite
+ * keeps zPType itself, so it must outlive the value, and calls a non-NULL
+ * xDestructor with pPtr when done with it.
+ *
+ * Wasm type `v(iiii)`. Signature `["sqlite3_result_pointer", undefined,
+ * "sqlite3_context*", "*", "string:static", "*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_pointer: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_pointer"];
+/**
+ * Sets the subtype of an application-defined function's result, keeping only
+ * its low 8 bits. The function must be registered with SQLITE_RESULT_SUBTYPE:
+ * without it the subtype might not be set, and a build with
+ * SQLITE_STRICT_SUBTYPE, such as this one, fails the function with an error.
+ * SQLite's table declares the first parameter as sqlite3_value*, but the C
+ * function takes sqlite3_context*.
+ *
+ * Wasm type `v(ii)`. Signature `["sqlite3_result_subtype", undefined,
+ * "sqlite3_value*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_subtype.html.
+ */
+export declare const sqlite3_result_subtype: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_subtype"];
+/**
+ * Makes an application-defined function fail with a copy of a UTF-8 message of
+ * n bytes, or up to its NUL terminator when n is negative. It resets the error
+ * code to SQLITE_ERROR, so call {@link sqlite3_result_error_code} after it.
+ *
+ * Wasm type `v(iii)`. Signature `["sqlite3_result_error", undefined,
+ * "sqlite3_context*", "string", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_error: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_error"];
+/**
+ * Makes an application-defined function fail with a result code instead of
+ * SQLITE_ERROR, and with the code's default message when no result was set.
+ * Call it after {@link sqlite3_result_error}, which resets the code to
+ * SQLITE_ERROR.
+ *
+ * Wasm type `v(ii)`. Signature `["sqlite3_result_error_code", undefined,
+ * "sqlite3_context*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_error_code: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_error_code"];
+/**
+ * Makes an application-defined function fail with SQLITE_NOMEM, as a failed
+ * memory allocation would.
+ *
+ * Wasm type `v(i)`. Signature `["sqlite3_result_error_nomem", undefined,
+ * "sqlite3_context*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_error_nomem: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_error_nomem"];
+/**
+ * Makes an application-defined function fail with SQLITE_TOOBIG, reporting a
+ * string or blob too big to represent.
+ *
+ * Wasm type `v(i)`. Signature `["sqlite3_result_error_toobig", undefined,
+ * "sqlite3_context*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/result_blob.html.
+ */
+export declare const sqlite3_result_error_toobig: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_result_error_toobig"];
+/**
+ * Returns the value of a URI query parameter of a filename, an empty string for
+ * a parameter without a value, or NULL when it is absent or the filename is
+ * NULL.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_uri_parameter", "string",
+ * "sqlite3_filename", "string"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/uri_boolean.html.
+ */
+export declare const sqlite3_uri_parameter: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_uri_parameter"];
+/**
+ * Returns 1 when a filename's URI query parameter is yes, true or on in any
+ * case or starts with a non-zero number, 0 when it is no, false or off or
+ * starts with zero, and whether bDefault is non-zero otherwise, including for a
+ * NULL filename.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_uri_boolean", "int",
+ * "sqlite3_filename", "string", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/uri_boolean.html.
+ */
+export declare const sqlite3_uri_boolean: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_uri_boolean"];
+/**
+ * Returns a URI query parameter of a filename SQLite created as a 64-bit
+ * integer, or iDefault when the filename is NULL or the parameter is missing or
+ * not a decimal or hexadecimal integer.
+ *
+ * Wasm type `j(iij)`. Signature `["sqlite3_uri_int64", "i64",
+ * "sqlite3_filename", "string", "i64"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/uri_boolean.html.
+ */
+export declare const sqlite3_uri_int64: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_uri_int64"];
+/**
+ * Returns the name of a filename's N-th URI query parameter, counting from 0,
+ * or NULL when N is out of range.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_uri_key", "string",
+ * "sqlite3_filename", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/uri_boolean.html.
+ */
+export declare const sqlite3_uri_key: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_uri_key"];
+/**
+ * Returns a registered VFS by name, or the default VFS for NULL.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_vfs_find", "*", "string"]` from
+ * SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vfs_find.html.
+ */
+export declare const sqlite3_vfs_find: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vfs_find"];
+/**
+ * Registers a VFS, optionally as the default. The struct and its name must
+ * outlive the registration.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_vfs_register", "int", "sqlite3_vfs*",
+ * "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vfs_find.html.
+ */
+export declare const sqlite3_vfs_register: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vfs_register"];
+/**
+ * Unregisters a VFS. When it was the default, SQLite makes an arbitrary other
+ * VFS the default.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_vfs_unregister", "int",
+ * "sqlite3_vfs*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vfs_find.html.
+ */
+export declare const sqlite3_vfs_unregister: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vfs_unregister"];
+/**
+ * Returns the ON CONFLICT mode of the statement that called xUpdate for an
+ * INSERT or UPDATE: SQLITE_ROLLBACK, SQLITE_IGNORE, SQLITE_FAIL, SQLITE_ABORT
+ * or SQLITE_REPLACE. Only xUpdate may call it.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_vtab_on_conflict", "int", "sqlite3*"]`
+ * from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vtab_on_conflict.html.
+ */
+export declare const sqlite3_vtab_on_conflict: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vtab_on_conflict"];
+/**
+ * Returns non-zero inside xColumn when the column is fetched for an UPDATE that
+ * does not change it, so xColumn may leave the result unset. It is only a hint
+ * and may always return 0.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_vtab_nochange", "int",
+ * "sqlite3_context*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vtab_nochange.html.
+ */
+export declare const sqlite3_vtab_nochange: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vtab_nochange"];
+/**
+ * Returns the collation name for text comparisons of an xBestIndex constraint,
+ * `BINARY` by default, or NULL for an index outside aConstraint. Only
+ * xBestIndex may call it, with the sqlite3_index_info it received.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_vtab_collation", "string",
+ * "sqlite3_index_info*", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vtab_collation.html.
+ */
+export declare const sqlite3_vtab_collation: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vtab_collation"];
+/**
+ * Returns how the planner needs a virtual table's rows for orderByConsumed: 0
+ * in aOrderBy order, 1 with equal aOrderBy values adjacent, 2 adjacent with
+ * duplicates over colUsed omittable, 3 in order with such duplicates omittable.
+ * Only xBestIndex may call it.
+ *
+ * Wasm type `i(i)`. Signature `["sqlite3_vtab_distinct", "int",
+ * "sqlite3_index_info*"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vtab_distinct.html.
+ */
+export declare const sqlite3_vtab_distinct: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vtab_distinct"];
+/**
+ * Returns non-zero when constraint iCons is an IN operator that can be
+ * processed all at once; bHandle 1 or 0 requests or declines that processing,
+ * and -1 only asks. Only xBestIndex may call it.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_vtab_in", "int",
+ * "sqlite3_index_info*", "int", "int"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vtab_in.html.
+ */
+export declare const sqlite3_vtab_in: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vtab_in"];
+/**
+ * Writes the first right-hand value of an all-at-once IN constraint, given its
+ * xFilter argument, to ppOut and returns SQLITE_OK, or writes NULL and returns
+ * SQLITE_DONE when there is none. The value stays valid until the next call or
+ * the end of xFilter.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_vtab_in_first", "int",
+ * "sqlite3_value*", "**"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vtab_in_first.html.
+ */
+export declare const sqlite3_vtab_in_first: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vtab_in_first"];
+/**
+ * Writes the next right-hand value of an all-at-once IN constraint, given its
+ * xFilter argument, to ppOut and returns SQLITE_OK, or writes NULL and returns
+ * SQLITE_DONE after the last. The value stays valid until the next call or the
+ * end of xFilter.
+ *
+ * Wasm type `i(ii)`. Signature `["sqlite3_vtab_in_next", "int",
+ * "sqlite3_value*", "**"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vtab_in_first.html.
+ */
+export declare const sqlite3_vtab_in_next: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vtab_in_next"];
+/**
+ * Writes the right-hand value of constraint iCons to ppVal and returns
+ * SQLITE_OK, or writes NULL and returns SQLITE_NOTFOUND when it is not known,
+ * which is usual unless it is a literal. Only xBestIndex may call it, and the
+ * value is freed when xBestIndex returns.
+ *
+ * Wasm type `i(iii)`. Signature `["sqlite3_vtab_rhs_value", "int",
+ * "sqlite3_index_info*", "int", "**"]` from SQLite's table.
+ *
+ * See https://sqlite.org/c3ref/vtab_rhs_value.html.
+ */
+export declare const sqlite3_vtab_rhs_value: (deps: SqliteWasmDep) => SqliteCExports["sqlite3_vtab_rhs_value"];
+/** An option of {@link sqlite3_config} that takes one int. */
+export type SqliteConfigIntOp = typeof SQLITE_CONFIG_MEMSTATUS | typeof SQLITE_CONFIG_URI | typeof SQLITE_CONFIG_COVERING_INDEX_SCAN | typeof SQLITE_CONFIG_STMTJRNL_SPILL | typeof SQLITE_CONFIG_SMALL_MALLOC | typeof SQLITE_CONFIG_SORTERREF_SIZE;
+/** An option of {@link sqlite3_config} and the arguments it takes. */
+export type SqliteConfigArgs = readonly [op: SqliteConfigIntOp, value: number] | readonly [op: typeof SQLITE_CONFIG_LOOKASIDE, sz: number, cnt: number] | readonly [op: typeof SQLITE_CONFIG_MEMDB_MAXSIZE, value: bigint];
+/**
+ * Changes a global option of the library, which works only before
+ * {@link sqlite3_initialize} or after {@link sqlite3_shutdown} and otherwise
+ * returns SQLITE_MISUSE. The loader initializes the library, so call it after
+ * sqlite3_shutdown, then initialize the library again with
+ * initializeSqliteWasm, as sqlite3_shutdown explains.
+ *
+ * - SQLITE_CONFIG_MEMSTATUS, SQLITE_CONFIG_SMALL_MALLOC, SQLITE_CONFIG_URI and
+ *   SQLITE_CONFIG_COVERING_INDEX_SCAN turn a feature on for a non-zero value
+ *   and off for 0.
+ * - SQLITE_CONFIG_STMTJRNL_SPILL sets the byte size above which statement
+ *   journals spill to disk. SQLITE_CONFIG_SORTERREF_SIZE fails with
+ *   SQLITE_ERROR, since this build does not enable sorter references.
+ * - SQLITE_CONFIG_LOOKASIDE sets the default lookaside allocator of new
+ *   connections to cnt slots of sz bytes.
+ * - SQLITE_CONFIG_MEMDB_MAXSIZE sets the default maximum size of a database
+ *   {@link sqlite3_deserialize} creates.
+ *
+ * The C function is variadic, so the binary does not export it. This calls the
+ * build's shim for the option's arguments and, as SQLite's JavaScript does,
+ * returns SQLITE_NOTFOUND for every other option without calling wasm, because
+ * the shims pass their arguments to the C function unchecked.
+ *
+ * Calls the build's shims, whose signatures come from Evolu's metadata because
+ * SQLite's table omits them:
+ *
+ * - `sqlite3__wasm_config_i`, wasm type `i(ii)`, signature
+ *   `["sqlite3__wasm_config_i", "int", "int", "int"]`.
+ * - `sqlite3__wasm_config_ii`, wasm type `i(iii)`, signature
+ *   `["sqlite3__wasm_config_ii", "int", "int", "int", "int"]`.
+ * - `sqlite3__wasm_config_j`, wasm type `i(ij)`, signature
+ *   `["sqlite3__wasm_config_j", "int", "int", "i64"]`.
+ *
+ * See https://sqlite.org/c3ref/config.html.
+ */
+export declare const sqlite3_config: (deps: SqliteWasmDep) => ((...args: SqliteConfigArgs) => SqliteResultCode);
+/**
+ * An option of {@link sqlite3_db_config} that takes an int and an `int*`: a
+ * flag, or SQLITE_DBCONFIG_FP_DIGITS.
+ */
+export type SqliteDbConfigIntOp = typeof SQLITE_DBCONFIG_ENABLE_FKEY | typeof SQLITE_DBCONFIG_ENABLE_TRIGGER | typeof SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION | typeof SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE | typeof SQLITE_DBCONFIG_ENABLE_QPSG | typeof SQLITE_DBCONFIG_TRIGGER_EQP | typeof SQLITE_DBCONFIG_RESET_DATABASE | typeof SQLITE_DBCONFIG_DEFENSIVE | typeof SQLITE_DBCONFIG_WRITABLE_SCHEMA | typeof SQLITE_DBCONFIG_LEGACY_ALTER_TABLE | typeof SQLITE_DBCONFIG_DQS_DML | typeof SQLITE_DBCONFIG_DQS_DDL | typeof SQLITE_DBCONFIG_ENABLE_VIEW | typeof SQLITE_DBCONFIG_LEGACY_FILE_FORMAT | typeof SQLITE_DBCONFIG_TRUSTED_SCHEMA | typeof SQLITE_DBCONFIG_STMT_SCANSTATUS | typeof SQLITE_DBCONFIG_REVERSE_SCANORDER | typeof SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE | typeof SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE | typeof SQLITE_DBCONFIG_ENABLE_COMMENTS | typeof SQLITE_DBCONFIG_FP_DIGITS;
+/** An option of {@link sqlite3_db_config} and the arguments it takes. */
+export type SqliteDbConfigArgs = readonly [op: typeof SQLITE_DBCONFIG_MAINDBNAME, zName: CStringPtr] | readonly [
+    op: typeof SQLITE_DBCONFIG_LOOKASIDE,
+    buf: WasmPtr | NullPtr,
+    sz: number,
+    cnt: number
+] | readonly [
+    op: SqliteDbConfigIntOp,
+    value: number,
+    pResult?: WasmPtr | NullPtr
+];
+/**
+ * Changes or reads an option of a connection, returning SQLITE_OK or an error
+ * code.
+ *
+ * - SQLITE_DBCONFIG_MAINDBNAME renames the main schema to zName, which SQLite
+ *   does not copy, so it must stay unchanged until the connection closes.
+ * - SQLITE_DBCONFIG_LOOKASIDE sets the connection's lookaside allocator to cnt
+ *   slots of sz bytes in buf, which must be 8-byte aligned and hold sz times
+ *   cnt bytes, or in memory SQLite allocates for a NULL buf. It fails with
+ *   SQLITE_BUSY while lookaside memory is in use.
+ * - SQLITE_DBCONFIG_FP_DIGITS sets the significant digits of floating-point to
+ *   text conversion to value when it is from 4 to 23, leaving the setting
+ *   unchanged otherwise, and writes the resulting setting to the int at pResult
+ *   unless it is NULL.
+ * - Every other option is a flag: a positive value sets it, 0 clears it and a
+ *   negative value only reads it, and the resulting 0 or 1 is written to the
+ *   int at pResult unless it is NULL. Changing a flag expires the connection's
+ *   prepared statements.
+ *
+ * The C function is variadic, so the binary does not export it. This calls the
+ * build's shim for the option's arguments and, as SQLite's JavaScript does,
+ * returns SQLITE_MISUSE for any other option without calling wasm.
+ *
+ * Calls the build's shims, whose signatures come from Evolu's metadata because
+ * SQLite's table omits them:
+ *
+ * - `sqlite3__wasm_db_config_s`, wasm type `i(iii)`, signature
+ *   `["sqlite3__wasm_db_config_s", "int", "sqlite3*", "int", "string"]`.
+ * - `sqlite3__wasm_db_config_pii`, wasm type `i(iiiii)`, signature
+ *   `["sqlite3__wasm_db_config_pii", "int", "sqlite3*", "int", "*", "int",
+ *   "int"]`.
+ * - `sqlite3__wasm_db_config_ip`, wasm type `i(iiii)`, signature
+ *   `["sqlite3__wasm_db_config_ip", "int", "sqlite3*", "int", "int", "int*"]`.
+ *
+ * See https://sqlite.org/c3ref/db_config.html.
+ */
+export declare const sqlite3_db_config: (deps: SqliteWasmDep) => ((db: SqliteDbPtr, ...args: SqliteDbConfigArgs) => SqliteResultCode);
+/** An option of {@link sqlite3_vtab_config} the build's shim supports. */
+export type SqliteVtabConfigOp = typeof SQLITE_VTAB_CONSTRAINT_SUPPORT | typeof SQLITE_VTAB_INNOCUOUS | typeof SQLITE_VTAB_DIRECTONLY;
+/**
+ * Sets an option of the virtual table whose xCreate or xConnect method is
+ * running, the only place it may be called.
+ *
+ * - SQLITE_VTAB_CONSTRAINT_SUPPORT with a non-zero value declares that xUpdate
+ *   returns SQLITE_CONSTRAINT only before changing anything, so SQLite can
+ *   honor the statement's ON CONFLICT mode.
+ * - SQLITE_VTAB_INNOCUOUS marks the virtual table as safe to use in triggers and
+ *   views, and SQLITE_VTAB_DIRECTONLY prohibits that. Both ignore value.
+ *
+ * The C function is variadic, so the binary does not export it. The build's
+ * shim returns SQLITE_MISUSE for any other option, including
+ * SQLITE_VTAB_USES_ALL_SCHEMAS, which it does not support.
+ *
+ * Returns the build's shim `sqlite3__wasm_vtab_config`, wasm type `i(iii)`,
+ * signature `["sqlite3__wasm_vtab_config", "int", "sqlite3*", "int", "int"]`.
+ * Its signature comes from Evolu's metadata because SQLite's table omits it.
+ *
+ * See https://sqlite.org/c3ref/vtab_config.html.
+ */
+export declare const sqlite3_vtab_config: (deps: SqliteWasmDep) => ((db: SqliteDbPtr, op: SqliteVtabConfigOp, value: number) => SqliteResultCode);
+//# sourceMappingURL=CApi.d.ts.map