@evolu/sqlite-wasm 2.2.4 → 3.53.4-build1

package/src/CApi.ts

@@ -0,0 +1,3294 @@
+/**
+ * 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,
+  SQLITE_MISUSE,
+  SQLITE_NOTFOUND,
+  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, installWasmFunctions } 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 const sqlite3_initialize = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_initialize"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_shutdown = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_shutdown"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_libversion = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_libversion"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_libversion_number = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_libversion_number"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_sourceid = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_sourceid"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_compileoption_get = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_compileoption_get"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_compileoption_used = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_compileoption_used"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_status = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_status"] => deps.sqliteWasm.exports.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 const sqlite3_status64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_status64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_auto_extension = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_auto_extension"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_cancel_auto_extension = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_cancel_auto_extension"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_reset_auto_extension = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_reset_auto_extension"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_randomness = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_randomness"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_complete = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_complete"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_keyword_count = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_keyword_count"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_keyword_name = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_keyword_name"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_keyword_check = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_keyword_check"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_strglob = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_strglob"] => deps.sqliteWasm.exports.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 const sqlite3_strlike = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_strlike"] => deps.sqliteWasm.exports.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 const sqlite3_stricmp = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_stricmp"] => deps.sqliteWasm.exports.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 const sqlite3_strnicmp = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_strnicmp"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_malloc = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_malloc"] => deps.sqliteWasm.exports.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 const sqlite3_malloc64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_malloc64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_realloc = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_realloc"] => deps.sqliteWasm.exports.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 const sqlite3_realloc64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_realloc64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_msize = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_msize"] => deps.sqliteWasm.exports.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 const sqlite3_free = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_free"] => deps.sqliteWasm.exports.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 const sqlite3_open = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_open"] => deps.sqliteWasm.exports.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 const sqlite3_open_v2 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_open_v2"] => deps.sqliteWasm.exports.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 const sqlite3_close_v2 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_close_v2"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_db_filename = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_db_filename"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_db_name = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_db_name"] => deps.sqliteWasm.exports.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 const sqlite3_db_readonly = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_db_readonly"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_txn_state = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_txn_state"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_get_autocommit = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_get_autocommit"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_limit = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_limit"] => deps.sqliteWasm.exports.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 const sqlite3_busy_handler = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_busy_handler"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_busy_timeout = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_busy_timeout"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_interrupt = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_interrupt"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_is_interrupted = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_is_interrupted"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_extended_result_codes = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_extended_result_codes"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_file_control = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_file_control"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_table_column_metadata = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_table_column_metadata"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_db_status = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_db_status"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_db_status64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_db_status64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_last_insert_rowid = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_last_insert_rowid"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_set_last_insert_rowid = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_set_last_insert_rowid"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_changes = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_changes"] => deps.sqliteWasm.exports.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 const sqlite3_changes64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_changes64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_total_changes = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_total_changes"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_total_changes64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_total_changes64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_exec = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_exec"] => deps.sqliteWasm.exports.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 const sqlite3_serialize = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_serialize"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_deserialize = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_deserialize"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_errcode = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_errcode"] => deps.sqliteWasm.exports.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 const sqlite3_extended_errcode = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_extended_errcode"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_errmsg = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_errmsg"] => deps.sqliteWasm.exports.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 const sqlite3_errstr = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_errstr"] => deps.sqliteWasm.exports.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 const sqlite3_error_offset = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_error_offset"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_set_errmsg = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_set_errmsg"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_commit_hook = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_commit_hook"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_rollback_hook = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_rollback_hook"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_update_hook = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_update_hook"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_trace_v2 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_trace_v2"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_collation_needed = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_collation_needed"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_prepare_v2 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_prepare_v2"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_prepare_v3 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_prepare_v3"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_step = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_step"] => deps.sqliteWasm.exports.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 const sqlite3_reset = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_reset"] => deps.sqliteWasm.exports.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 const sqlite3_finalize = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_finalize"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_next_stmt = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_next_stmt"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_db_handle = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_db_handle"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_sql = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_sql"] => deps.sqliteWasm.exports.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 const sqlite3_expanded_sql = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_expanded_sql"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_stmt_busy = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_stmt_busy"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_stmt_readonly = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_stmt_readonly"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_stmt_explain = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_stmt_explain"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_stmt_isexplain = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_stmt_isexplain"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_stmt_status = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_stmt_status"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_parameter_count = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_parameter_count"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_parameter_index = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_parameter_index"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_parameter_name = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_parameter_name"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_null = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_null"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_int = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_int"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_int64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_int64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_double = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_double"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_text = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_text"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_blob = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_blob"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_zeroblob = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_zeroblob"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_bind_pointer = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_bind_pointer"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_clear_bindings = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_clear_bindings"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_count = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_count"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_data_count = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_data_count"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_name = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_name"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_decltype = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_decltype"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_type = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_type"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_int = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_int"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_int64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_int64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_double = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_double"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_text = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_text"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_blob = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_blob"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_bytes = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_bytes"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_column_value = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_column_value"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_type = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_type"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_numeric_type = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_numeric_type"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_int = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_int"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_int64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_int64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_double = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_double"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_text = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_text"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_blob = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_blob"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_bytes = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_bytes"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_pointer = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_pointer"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_subtype = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_subtype"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_frombind = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_frombind"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_nochange = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_nochange"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_dup = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_dup"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_value_free = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_value_free"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_create_function = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_create_function"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_create_function_v2 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_create_function_v2"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_overload_function = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_overload_function"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_create_collation = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_create_collation"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_create_collation_v2 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_create_collation_v2"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_user_data = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_user_data"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_context_db_handle = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_context_db_handle"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_aggregate_context = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_aggregate_context"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_get_auxdata = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_get_auxdata"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_set_auxdata = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_set_auxdata"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_null = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_null"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_int = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_int"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_int64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_int64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_double = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_double"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_text = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_text"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_blob = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_blob"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_zeroblob = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_zeroblob"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_zeroblob64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_zeroblob64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_pointer = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_pointer"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_subtype = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_subtype"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_error = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_error"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_error_code = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_error_code"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_error_nomem = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_error_nomem"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_result_error_toobig = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_result_error_toobig"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_uri_parameter = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_uri_parameter"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_uri_boolean = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_uri_boolean"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_uri_int64 = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_uri_int64"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_uri_key = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_uri_key"] => deps.sqliteWasm.exports.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 const sqlite3_vfs_find = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vfs_find"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_vfs_register = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vfs_register"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_vfs_unregister = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vfs_unregister"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_vtab_on_conflict = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vtab_on_conflict"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_vtab_nochange = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vtab_nochange"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_vtab_collation = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vtab_collation"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_vtab_distinct = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vtab_distinct"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_vtab_in = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vtab_in"] => deps.sqliteWasm.exports.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 const sqlite3_vtab_in_first = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vtab_in_first"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_vtab_in_next = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vtab_in_next"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_vtab_rhs_value = (
+  deps: SqliteWasmDep,
+): SqliteCExports["sqlite3_vtab_rhs_value"] =>
+  deps.sqliteWasm.exports.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 const sqlite3_config = (
+  deps: SqliteWasmDep,
+): ((...args: SqliteConfigArgs) => SqliteResultCode) => {
+  const {
+    sqlite3__wasm_config_i,
+    sqlite3__wasm_config_ii,
+    sqlite3__wasm_config_j,
+  } = deps.sqliteWasm.exports;
+  return (...args) => {
+    switch (args[0]) {
+      case SQLITE_CONFIG_MEMSTATUS:
+      case SQLITE_CONFIG_URI:
+      case SQLITE_CONFIG_COVERING_INDEX_SCAN:
+      case SQLITE_CONFIG_STMTJRNL_SPILL:
+      case SQLITE_CONFIG_SMALL_MALLOC:
+      case SQLITE_CONFIG_SORTERREF_SIZE:
+        return sqlite3__wasm_config_i(args[0], args[1]);
+      case SQLITE_CONFIG_LOOKASIDE:
+        return sqlite3__wasm_config_ii(args[0], args[1], args[2]);
+      case SQLITE_CONFIG_MEMDB_MAXSIZE:
+        return sqlite3__wasm_config_j(args[0], args[1]);
+      default:
+        // TypeScript rejects other options, but JavaScript and casts can pass
+        // them.
+        return SQLITE_NOTFOUND;
+    }
+  };
+};
+
+/**
+ * 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 const sqlite3_db_config = (
+  deps: SqliteWasmDep,
+): ((db: SqliteDbPtr, ...args: SqliteDbConfigArgs) => SqliteResultCode) => {
+  const {
+    sqlite3__wasm_db_config_s,
+    sqlite3__wasm_db_config_pii,
+    sqlite3__wasm_db_config_ip,
+  } = deps.sqliteWasm.exports;
+  return (db, ...args) => {
+    switch (args[0]) {
+      case SQLITE_DBCONFIG_MAINDBNAME:
+        return sqlite3__wasm_db_config_s(db, args[0], args[1]);
+      case SQLITE_DBCONFIG_LOOKASIDE:
+        return sqlite3__wasm_db_config_pii(
+          db,
+          args[0],
+          args[1],
+          args[2],
+          args[3],
+        );
+      case SQLITE_DBCONFIG_ENABLE_FKEY:
+      case SQLITE_DBCONFIG_ENABLE_TRIGGER:
+      case SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION:
+      case SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE:
+      case SQLITE_DBCONFIG_ENABLE_QPSG:
+      case SQLITE_DBCONFIG_TRIGGER_EQP:
+      case SQLITE_DBCONFIG_RESET_DATABASE:
+      case SQLITE_DBCONFIG_DEFENSIVE:
+      case SQLITE_DBCONFIG_WRITABLE_SCHEMA:
+      case SQLITE_DBCONFIG_LEGACY_ALTER_TABLE:
+      case SQLITE_DBCONFIG_DQS_DML:
+      case SQLITE_DBCONFIG_DQS_DDL:
+      case SQLITE_DBCONFIG_ENABLE_VIEW:
+      case SQLITE_DBCONFIG_LEGACY_FILE_FORMAT:
+      case SQLITE_DBCONFIG_TRUSTED_SCHEMA:
+      case SQLITE_DBCONFIG_STMT_SCANSTATUS:
+      case SQLITE_DBCONFIG_REVERSE_SCANORDER:
+      case SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE:
+      case SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE:
+      case SQLITE_DBCONFIG_ENABLE_COMMENTS:
+      case SQLITE_DBCONFIG_FP_DIGITS:
+        return sqlite3__wasm_db_config_ip(db, args[0], args[1], args[2] ?? 0);
+      default:
+        // TypeScript rejects other options, but JavaScript and casts can pass
+        // them.
+        return SQLITE_MISUSE;
+    }
+  };
+};
+
+/** 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 const sqlite3_vtab_config = (
+  deps: SqliteWasmDep,
+): ((
+  db: SqliteDbPtr,
+  op: SqliteVtabConfigOp,
+  value: number,
+) => SqliteResultCode) => deps.sqliteWasm.exports.sqlite3__wasm_vtab_config;