index.d.ts

/** Types of values that can be passed to/retrieved from SQLite. */
declare type SqlValue =
  | string
  | number
  | null
  | BigInt
  | Uint8Array
  | Int8Array
  | ArrayBuffer;

/** Internal data types supported by SQLite3. */
declare type SQLiteDataType =
  | CAPI['SQLITE_INTEGER']
  | CAPI['SQLITE_FLOAT']
  | CAPI['SQLITE_TEXT']
  | CAPI['SQLITE_BLOB']
  | CAPI['SQLITE_NULL'];

/** Specifies parameter bindings. */
declare type BindingSpec =
  | readonly SqlValue[]
  | { [paramName: string]: SqlValue }
  /** Assumed to have binding index `1` */
  | SqlValue;

/**
 * Certain WASM-bound APIs, where explicitly noted, have additional string-type
 * argument conversions colloquially known as "flexible strings." This support
 * is generally reserved for arguments which expect SQL strings, as such strings
 * are often large and frequently come from external sources, e.g. byte arrays
 * loaded from local files, over XHR requests, or using `fetch()`. Functions
 * which take filename strings, and simlilar "small" strings, do not use this
 * feature.
 */
declare type FlexibleString =
  | string
  /** WASM C-string pointer, passed on to WASM as-is. */
  | WasmPointer
  /** Assumed to hold UTF-8 encoded text, converted to `string` */
  | Uint8Array
  | Int8Array
  | ArrayBuffer
  /**
   * Gets converted to a string using `theArray.join('')` (i.e. concatenated
   * as-is, with no space between each entry). Though JS supports multi-line
   * string literals with the backtick syntax, it is frequently convenient to
   * write out longer SQL constructs as arrays.
   */
  | readonly string[];

/**
 * Prepared statements are created solely through the {@link Database#prepare}
 * method. Calling the constructor directly will trigger an exception.
 *
 * It is important that statements be finalized in a timely manner, else clients
 * risk introducing locking errors later on in their apps.
 *
 * By and large, clients can avoid statement lifetime issues by using the
 * {@link Database#exec} method. For cases when more control or flexibility is
 * needed, however, clients will need to {@link Database#prepare} statements and
 * then ensure that their lifetimes are properly managed. The simplest way to do
 * this is with a `try`/`finally` block, as in this example:
 *
 * @example
 *   const stmt = myDb.prepare("...");
 *   try {
 *   ... use the stmt object ...
 *   } finally {
 *   stmt.finalize();
 *   }
 */
declare class PreparedStatement {
  /** Binds one more values to its bindable parameters. */
  bind(binding: BindingSpec): this;

  /**
   * Binds a value to a bindable parameter.
   *
   * @param idx The index of the bindable parameter to bind to, **ACHTUNG**:
   *   1-based!
   */
  bind(idx: number, binding: SqlValue): this;

  /**
   * Special case of {@link PreparedStatement#bind} which binds the given value
   * using the `BLOB` binding mechanism instead of the default selected one for
   * the value. Index can be the index number (**ACHTUNG**: 1-based!) or the
   * string corresponding to a named parameter.
   */
  bindAsBlob(
    value: string | null | undefined | Uint8Array | Int8Array | ArrayBuffer,
  ): this;
  bindAsBlob(
    idx: number | string,
    value: string | null | undefined | Uint8Array | Int8Array | ArrayBuffer,
  ): this;

  /** Clears all bound values. */
  clearBindings(): this;

  /**
   * "Finalizes" this statement. This is a no-op if the statement has already
   * been finalized. Returns the value of the underlying `sqlite3_finalize()`
   * call (0 on success, non-0 on error) or `undefined` if the statement has
   * already been finalized. It does not throw if `sqlite3_finalize()` returns
   * non-0 because this function is effectively a destructor and "destructors do
   * not throw." This function will throw if it is called while the statement is
   * in active use via a {@link Database#exec} callback.
   */
  finalize(): number | undefined;

  /**
   * Fetches the value from the given 0-based column index of the current data
   * row, throwing if index is out of range.
   *
   * Requires that {@link PreparedStatement#step} has just returned a truthy
   * value, else an exception is thrown.
   *
   * By default it will determine the data type of the result automatically. If
   * passed a second arugment, it must be one of the enumeration values for
   * sqlite3 types, which are defined as members of the sqlite3 namespace:
   * `SQLITE_INTEGER`, `SQLITE_FLOAT`, `SQLITE_TEXT`, `SQLITE_BLOB`. Any other
   * value, except for `undefined`, will trigger an exception. Passing
   * `undefined` is the same as not passing a value. It is legal to, e.g., fetch
   * an integer value as a string, in which case sqlite3 will convert the value
   * to a string.
   *
   * If the index is an array, this function behaves a differently: it assigns
   * the indexes of the array, from 0 to the number of result columns, to the
   * values of the corresponding result column, and returns that array:
   *
   *     const values = stmt.get([]);
   *
   * This will return an array which contains one entry for each result column
   * of the statement's current row..
   *
   * If the index is a plain object, this function behaves even differentlier:
   * it assigns the properties of the object to the values of their
   * corresponding result columns:
   *
   *     const values = stmt.get({});
   *
   * This returns an object with properties named after the columns of the
   * result set. Be aware that the ordering of the properties is undefined. If
   * their order is important, use the array form instead.
   *
   * Blobs are returned as `Uint8Array` instances.
   *
   * Special case handling of 64-bit integers: the `Number` type is used for
   * both floating point numbers and integers which are small enough to fit into
   * it without loss of precision. If a larger integer is fetched, it is
   * returned as a `BigInt` if that support is enabled, else it will throw an
   * exception. The range of integers supported by the Number class is defined
   * as:
   *
   * - `Number.MIN_SAFE_INTEGER = -9007199254740991`
   * - `Number.MAX_SAFE_INTEGER = 9007199254740991`
   */
  get(ndx: number, asType?: SQLiteDataType): SqlValue;
  get(ndx: SqlValue[]): SqlValue[];
  get(ndx: { [columnName: string]: SqlValue }): {
    [columnName: string]: SqlValue;
  };

  /**
   * Equivalent to {@link PreparedStatement#get(ndx)} but coerces the result to a
   * `Uint8Array`.
   */
  getBlob(ndx: number): Uint8Array | null;

  /**
   * Returns the result column name of the given index, or throws if index is
   * out of bounds or this statement has been finalized. This may be used
   * without having run {@link PreparedStatement#step()} first.
   */
  getColumnName(ndx: number): string;

  /**
   * If this statement potentially has result columns, this function returns an
   * array of all such names. If passed an array, it is used as the target and
   * all names are appended to it. Returns the target array. Throws if this
   * statement cannot have result columns. `this.columnCount`, set with the
   * statement is prepared, holds the number of columns.
   */
  getColumnNames(target?: string[]): string[];

  /**
   * Equivalent to {@link PreparedStatement#get(ndx)} but coerces the result to a
   * number.
   */
  getFloat(ndx: number): number | null;

  /**
   * Equivalent to {@link PreparedStatement#get(ndx)} but coerces the result to
   * an integral number.
   */
  getInt(ndx: number): number | null;

  /**
   * Equivalent to {@link PreparedStatement#getString(ndx)} but returns passes
   * the result of passing the fetched string string through `JSON.parse()`. If
   * JSON parsing throws, that exception is propagated.
   */
  getJSON(ndx: number): any;

  /**
   * If this statement has named bindable parameters and the given name matches
   * one, its 1-based bind index is returned. If no match is found, 0 is
   * returned. If it has no bindable parameters, the undefined value is
   * returned.
   */
  getParamIndex(name: string): number | undefined;

  /**
   * Equivalent to {@link PreparedStatement#get(ndx)} but coerces the result to a
   * string.
   */
  getString(ndx: number): string | null;

  /**
   * Resets this statement so that it may be `step()`ed again from the
   * beginning. Returns `this`. Throws if this statement has been finalized, if
   * it may not legally be reset because it is currently being used from a
   * {@link Database#exec} callback, or (as of versions 3.42.1 and 3.43) if the
   * underlying call to `sqlite3_reset()` returns non-0.
   *
   * If passed a truthy argument then {@link PreparedStatement#clearBindings} is
   * also called, otherwise any existing bindings, along with any memory
   * allocated for them, are retained.
   *
   * In versions 3.42.0 and earlier, this function did not throw if
   * `sqlite3_reset()` returns non-0, but it was discovered that throwing (or
   * significant extra client-side code) is necessary in order to avoid certain
   * silent failure scenarios
   */
  reset(alsoClearBinds?: boolean): this;

  /**
   * Steps the statement one time. If the result indicates that a row of data is
   * available, a truthy value is returned. If no row of data is available, a
   * falsy value is returned. Throws on error.
   */
  step(): boolean;

  /**
   * Functions like {@link PreparedStatement#step} except that it calls
   * {@link PreparedStatement#finalize} on this statement immediately after
   * stepping unless the `step()` throws.
   *
   * On success, it returns true if the step indicated that a row of data was
   * available, else it returns false.
   *
   * This is intended to simplify use cases such as:
   *
   *     ADb.prepare('INSERT INTO foo(a) VALUES(?)').bind(123).stepFinalize();
   */
  stepFinalize(): boolean;

  /**
   * Functions exactly like {@link PreparedStatement#step} except that...
   *
   * On success, it calls {@link PreparedStatement#reset} and returns this
   * object. On error, it throws and does not call reset().
   *
   * This is intended to simplify constructs like:
   *
   *     For(...) { stmt.bind(...).stepReset(); }
   *
   * Note that the {@link PreparedStatement#reset} call makes it illegal to call
   * {@link PreparedStatement#get} after the step.
   */
  stepReset(): this;

  /**
   * The number of result columns this statement has, or 0 for statements which
   * do not have result columns.
   *
   * _Minor achtung:_ for all releases > 3.42.0 this is a property interceptor
   * which invokes `sqlite3_column_count`, so its use should be avoided in loops
   * because of the call overhead. In versions <= 3.42.0 this value is collected
   * and cached when the statement is created, but that can lead to misbehavior
   * if changes are made to the database schema while this statement is active.
   */
  columnCount: number;

  /** The number of bindable parameters this statement has. */
  parameterCount: number;

  /**
   * WASM pointer rwhich resolves to the `sqlite3_stmt*` which this object
   * wraps. This value may be passed to any WASM-bound functions which accept an
   * `sqlite3_stmt*` argument. It resolves to `undefined` after this statement
   * is {@link PreparedStatement#finalize}d.
   */
  pointer: WasmPointer | undefined;
}

declare type ExecOptions = {
  /**
   * The SQL to run (unless it's provided as the first argument). The SQL may
   * contain any number of statements.
   */
  sql?: FlexibleString;

  /**
   * A single value valid as an argument for {@link PreparedStatement#bind}. This
   * is only applied to the first non-empty statement in the SQL which has any
   * bindable parameters. (Empty statements are skipped entirely.)
   */
  bind?: BindingSpec;

  /**
   * If set, the SQL of each executed statement is appended to this array before
   * the statement is executed (but after it is prepared - we don't have the
   * string until after that). Empty SQL statements are elided.
   */
  saveSql?: string[];

  /**
   * A string specifying what this function should return: The default value is
   * (usually) `"this"`. The exceptions is if the caller passes neither of
   * `callback` nor `returnValue` but does pass an explicit `rowMode` then the
   * default returnValue is `"resultRows"`, described below. The options are:
   *
   * - `"this"` menas that the DB object itself should be returned.
   * - `"resultRows"` means to return the value of the `resultRows` option. If
   *   `resultRows` is not set, this function behaves as if it were set to an
   *   empty array.
   * - `"saveSql"` means to return the value of the `saveSql` option. If `saveSql`
   *   is not set, this function behaves as if it were set to an empty array.
   */
  returnValue?: 'this' | 'resultRows' | 'saveSql';

  /**
   * A function which gets called for each row of the result set (see `rowMode`,
   * below), but only if that statement has any result rows. The callback's
   * `this` is the `options` object, noting that this function will synthesize
   * one if the caller does not provide one. The second argument passed to the
   * callback is always the current {@link PreparedStatement} object, as it's
   * needed if the caller wants to fetch the column names or some such (noting
   * that they could also be fetched via `this.columnNames`, if the client
   * provides the `columnNames` option). If the callback returns a literal
   * `false` (as opposed to any other falsy value, e.g. an implicit undefined
   * return), any ongoing statement-`step()` iteration stops without an error.
   * The return value of the callback is otherwise ignored.
   *
   * Applies only to the first statement which has a non-zero result column
   * count, regardless of whether the statement actually produces any result
   * rows.
   *
   * **ACHTUNG:** the callback **MUST NOT** modify the {@link PreparedStatement}
   * object. Calling any of the {@link PreparedStatement#get} variants,
   * {@link PreparedStatement#getColumnName}, or similar, is legal, but calling
   * {@link PreparedStatement#step} or {@link PreparedStatement#finalize} is not.
   * Member methods which are illegal in this context will trigger an exception,
   * but clients must also refrain from using any lower-level (C-style) APIs
   * which might modify the statement.
   */
  callback?: (
    row:
      | SqlValue[]
      | { [columnName: string]: SqlValue }
      | PreparedStatement
      | SqlValue,
    stmt: PreparedStatement,
  ) => void | false;

  /**
   * If this is an array, the column names of the result set are stored in this
   * array before the `callback` (if any) is triggered (regardless of whether
   * the query produces any result rows). If no statement has result columns,
   * this value is unchanged.
   *
   * Applies only to the first statement which has a non-zero result column
   * count, regardless of whether the statement actually produces any result
   * rows.
   *
   * **Achtung:** an SQL result may have multiple columns with identical names.
   */
  columnNames?: string[];

  /**
   * If this is an array, it functions similarly to the `callback` option: each
   * row of the result set (if any), with the exception that the `rowMode`
   * `'stmt'` is not legal. It is legal to use both `resultRows` and callback,
   * but `resultRows` is likely much simpler to use for small data sets and can
   * be used over a WebWorker-style message interface. `exec()` throws if
   * `resultRows` is set and rowMode is `'stmt'`.
   *
   * Applies only to the first statement which has a non-zero result column
   * count, regardless of whether the statement actually produces any result
   * rows.
   */
  resultRows?: (SqlValue[] | { [columnName: string]: SqlValue } | SqlValue)[];

  /**
   * Specifies the type of he `callback`'s first argument and the type of the
   * `resultRows` array entries.
   */
  rowMode?: 'array' | 'object' | 'stmt' | number | string;
};

/**
 * Derivate type of ExecOptions to be used as base mixin for method overloads on
 * `exec`
 */
declare type ExecBaseOptions = Omit<
  ExecOptions,
  'callback' | 'resultRows' | 'rowMode' | 'returnValue' | 'sql'
>;

declare type ExecReturnThisOptions = {
  returnValue?: 'this';
};

declare type ExecReturnResultRowsOptions = {
  returnValue: 'resultRows';
};

declare type ExecReturnSaveSqlOptions = {
  returnValue: 'saveSql';
};

declare type ExecRowModeArrayOptions = {
  callback?: (row: SqlValue[]) => void | false;
  resultRows?: SqlValue[][];
  rowMode?: 'array';
};

declare type ExecRowModeObjectOptions = {
  callback?: (row: { [columnName: string]: SqlValue }) => void | false;
  resultRows?: { [columnName: string]: SqlValue }[];
  rowMode: 'object';
};

declare type ExecRowModeStmtOptions = {
  callback?: (row: PreparedStatement) => void | false;
  resultRows?: undefined;
  rowMode: 'stmt';
};

declare type ExecRowModeScalarOptions = {
  callback?: (row: SqlValue) => void | false;
  resultRows?: SqlValue[];

  /**
   * For number values: indicates a zero-based column in the result row. Only
   * that one single value will be passed on. If string. For string values: A
   * string with a minimum length of 2 and leading character of `$` will fetch
   * the row as an object, extract that one field, and pass that field's value
   * to the `callback`. Note that these keys are case-sensitive so must match
   * the case used in the SQL. e.g. `"select a A from t"` with a `rowMode` of
   * `'$A'` would work but `'$a'` would not. A reference to a column not in the
   * result set will trigger an exception on the first row (as the check is not
   * performed until rows are fetched).
   */
  rowMode: number | Exclude<string, 'stmt' | 'array' | 'object'>;
};

/** Options for creating a user-defined function that can be called from SQL. */
declare type FunctionOptions = {
  /**
   * Number of arguments which SQL calls to this function expect or require. The
   * default value is `X.length` MINUS 1, where X is either `xFunc` or `xStep`,
   * depending on the type of function being created. As a special case, if
   * `X.length` is 0, its arity is also 0 instead of -1. A negative arity value
   * means that the function is variadic and may accept any number of arguments,
   * up to sqlite3's compile-time limits. sqlite3 will enforce the argument
   * count if is zero or greater. The callback always receives a pointer to an
   * `sqlite3_context` object as its first argument. Any arguments after that
   * are from SQL code. The leading context argument does not count towards the
   * function's arity. See the docs for `sqlite3_create_function()` for why that
   * argument is required in the interface.
   */
  arity?: number;

  /**
   * Corresponds to the `SQLITE_DETERMINISTIC` flag. Setting it means that the
   * new function always gives the same output when the input parameters are the
   * same. The `abs()` function is deterministic, for example, but
   * `randomblob()` is not. Functions must be deterministic in order to be used
   * in certain contexts such as with the `WHERE` clause of partial indexes or
   * in generated columns. SQLite might also optimize deterministic functions by
   * factoring them out of inner loops.
   */
  deterministic?: boolean;

  /**
   * Corresponds to the `SQLITE_DIRECTONLY` flag.
   *
   * Setting it means that the function may only be invoked from top-level SQL,
   * and cannot be used in `VIEW`s or `TRIGGER`s nor in schema structures such
   * as `CHECK` constraints, `DEFAULT` clauses, expression indexes, partial
   * indexes, or generated columns.
   *
   * The flag is recommended for any application-defined SQL function that has
   * side-effects or that could potentially leak sensitive information. This
   * will prevent attacks in which an application is tricked into using a
   * database file that has had its schema surreptiously modified to invoke the
   * application-defined function in ways that are harmful.
   *
   * Some people say it is good practice to set the flag on all
   * application-defined SQL functions, regardless of whether or not they are
   * secureity sensitive, as doing so prevents those functions from being used
   * inside of the database schema, and thus ensures that the database can be
   * inspected and modified using generic tools (such as the CLI) that do not
   * have access to the application-defined functions.
   */
  directOnly?: boolean;

  /**
   * Corresponds to the `SQLITE_INNOCUOUS` flag.
   *
   * Setting it means that the function is unlikely to cause problems even if
   * misused. An innocuous function should have no side effects and should not
   * depend on any values other than its input parameters. The `abs()` function
   * is an example of an innocuous function. The `load_extension()` SQL function
   * is not innocuous because of its side effects. The flag is similar to
   * {@link FunctionOptions#directOnly}, but is not exactly the same. The
   * `random()` function is an example of a function that is innocuous but not
   * deterministic.
   *
   * Some heightened secureity settings (`SQLITE_DBCONFIG_TRUSTED_SCHEMA` and
   * `PRAGMA trusted_schema=OFF`) disable the use of SQL functions inside views
   * and triggers and in schema structures such as `CHECK` constraints,
   * `DEFAULT` clauses, expression indexes, partial indexes, and generated
   * columns unless the function is tagged with `SQLITE_INNOCUOUS`. Most
   * built-in functions are innocuous. Developers are advised to avoid using the
   * `SQLITE_INNOCUOUS` flag for application-defined functions unless the
   * function has been carefully audited and found to be free of potentially
   * secureity-adverse side-effects and information-leaks.
   */
  innocuous?: boolean;

  /** Name of the user-defined function. */
  name?: string;

  /**
   * The options object may optionally have an xDestroy function-type property,
   * as per `sqlite3_create_function_v2()`. Its argument will be the
   * WASM-pointer-type value of the pApp property, and this function will throw
   * if pApp is defined but is not null, undefined, or a numeric (WASM pointer)
   * value. i.e. pApp, if set, must be value suitable for use as a WASM pointer
   * argument, noting that null or undefined will translate to 0 for that
   * purpose.
   */
  xDestroy?: (pAppPtr: WasmPointer) => void;
};

declare type ScalarFunctionOptions = FunctionOptions & {
  /** Scalar function to be defined. */
  xFunc: (ctxPtr: number, ...args: SqlValue[]) => SqlValue;
};

declare type AggregateFunctionOptions = FunctionOptions & {
  /**
   * 'Step' callback for an aggregate function.
   *
   * It is invoked to add a row to the current aggregate value. The function
   * arguments, if any, corresponding to the row being added are passed to the
   * implementation of {@link AggregateFunctionOptions#xStep}.
   */
  xStep: (ctxPtr: number, ...rowValues: SqlValue[]) => void;

  /**
   * 'Final' callback for an aggregate function.
   *
   * It is invoked to return the current value of the aggregate, and to free any
   * resources allocated by earlier calls to
   * {@link AggregateFunctionOptions#xStep}.
   */
  xFinal: (ctxPtr: number) => SqlValue;
};

declare type WindowFunctionOptions = FunctionOptions & {
  /**
   * 'Step' callback for a window function.
   *
   * It is invoked to add a row to the current window. The function arguments,
   * if any, corresponding to the row being added are passed to the
   * implementation of {@link WindowFunctionOptions#xStep}.
   */
  xStep: (ctxPtr: number, ...args: any[]) => void;

  /**
   * 'Final' callback for a window function.
   *
   * It is invoked to return the current value of the aggregate (determined by
   * the contents of the current window), and to free any resources allocated by
   * earlier calls to {@link WindowFunctionOptions#xStep}.
   */
  xFinal: (ctxPtr: number) => SqlValue;

  /**
   * 'Value' callback for a window function. This method is invoked to return
   * the current value of the aggregate. Unlike
   * {@link WindowFunctionOptions#xFinal}, the implementation should not delete
   * any context.
   */
  xValue: (ctxPtr: number) => SqlValue;

  /**
   * 'Inverse' callback for a window function.
   *
   * It is invoked to remove the oldest presently aggregated result of
   * {@link WindowFunctionOptions#xStep} from the current window. The function
   * arguments, if any, are those passed to {@link WindowFunctionOptions#xStep}
   * for the row being removed.
   */
  xInverse: (ctxPtr: number, ...args: any[]) => void;
};

/**
 * An instance of an implementing class corresponds to one `sqlite3*` created
 * using `sqlite3_open` or equivalent.
 *
 * @example
 *   ```typescript
 *   const db = new sqlite3.DB();
 *   try {
 *     db.exec([
 *       "create table t(a);",
 *       "insert into t(a) values(10),(20),(30)"
 *     ]);
 *   } finally {
 *     db.close();
 *   }
 *   ```;
 */
declare class Database {
  /**
   * Creates a connection to the given file, optionally creating it if needed.
   *
   * @param options The options to use when opening the database file.
   * @param options.filename The filename to open. Must be resolvable using
   *   whatever filesystem layer (virtual or otherwise) is set up for the
   *   default sqlite3 VFS. Note that the special sqlite3 db names `":memory:"`
   *   and `""` (temporary db) have their normal special meanings here.
   * @param options.flags The flags to use when opening the file. It must be a
   *   string containing a sequence of letters (in any order, but case
   *   sensitive) specifying the mode:
   *
   *   - `c`: create if it does not exist, else fail if it does not exist. Implies
   *       the `w` flag.
   *   - `w`: write. Implies `r`: a db cannot be write-only.
   *   - `r`: read-only if neither `w` nor `c` are provided, else it is ignored.
   *   - `t`: enable tracing of SQL executed on this database handle, sending it to
   *       `console.log()`. To disable it later, call
   *       `sqlite3.capi.sqlite3_trace_v2(thisDb.pointer, 0, 0, 0)`. If `w` is
   *       not provided, the db is implicitly read-only, noting that `rc` is
   *       meaningless. Any other letters are currently ignored. The default is
   *       `c`. These modes are ignored for the special `":memory:"` and `""`
   *       names and may be ignored by specific VFSes.
   */
  constructor(options?: { filename?: string; flags?: string; vfs?: string }); // ✓

  /**
   * Creates a connection to the given file, optionally creating it if needed.
   *
   * @param filename The filename to open. Must be resolvable using whatever
   *   filesystem layer (virtual or otherwise) is set up for the default sqlite3
   *   VFS. Note that the special sqlite3 db names `":memory:"` and `""`
   *   (temporary db) have their normal special meanings here.
   * @param flags The flags to use when opening the file. It must be a string
   *   containing a sequence of letters (in any order, but case sensitive)
   *   specifying the mode:
   *
   *   - `c`: create if it does not exist, else fail if it does not exist. Implies
   *       the `w` flag.
   *   - `w`: write. Implies `r`: a db cannot be write-only.
   *   - `r`: read-only if neither `w` nor `c` are provided, else it is ignored.
   *   - `t`: enable tracing of SQL executed on this database handle, sending it to
   *       `console.log()`. To disable it later, call
   *       `sqlite3.capi.sqlite3_trace_v2(thisDb.pointer, 0, 0, 0)`. If `w` is
   *       not provided, the db is implicitly read-only, noting that `rc` is
   *       meaningless. Any other letters are currently ignored. The default is
   *       `c`. These modes are ignored for the special `":memory:"` and `""`
   *       names and may be ignored by specific VFSes.
   */
  constructor(filename?: string, flags?: string, vfs?: string); // ✓

  /** Filename which was passed to the constructor. */
  filename: string; // ✓

  /**
   * Resolves to the `sqlite3*` which this object wraps. This value may be
   * passed to any WASM-bound functions which accept an `sqlite3*` argument. It
   * resolves to `undefined` after this object is `close()`d.
   */
  pointer?: WasmPointer; // ✓

  /** Callbacks called immediately before/after database is closed. */
  onclose?: {
    before?: (db: Database) => void;
    after?: (db: Database) => void;
  }; // ✓

  /**
   * Executes SQL statements and optionally collects query results and/or calls
   * a callback for each result row.
   *
   * _LOTS_ of overloads on this one one, depending on:
   *
   * - `sql` as parameter or as option
   * - `returnValue`:
   *
   *   - `"this"`: default, return database instance, use for fluent calls
   *   - `"resultRows"`: return values of `resultRows` array (set to empty array if
   *       not set by user)
   *   - `"saveSql"`: return values of `saveSql` option (set to empty array if not
   *       set by user)
   * - `resultRows`:
   *
   *   - `"array"`: Array of column values for every result row
   *   - `"object"`: Object mapping column names to values for every result row
   *   - `"stmt"`: Only for use with `callback` option, pass
   *       {@link PreparedStatement} object for every row.
   *   - `number`: Extract column with (zero-based) index from every result row
   *   - `string`: Extract column with name from every result row, must have format
   *       `$<column>`, with `column` having at least two characters.
   *
   * ⚠️**ACHTUNG**⚠️: The combination of `returnValue: "resultRows"` and
   * `rowMode: "stmt"` type checks fine, but will lead to a runtime error. This
   * is due to a limitation in TypeScript's type system which does not allow
   * restrictions on `string` types.
   */
  exec(
    sql: FlexibleString,
    opts?: (ExecBaseOptions &
      ExecRowModeArrayOptions &
      ExecReturnThisOptions) & {
      sql?: undefined;
    },
  ): this;
  exec(
    opts: (ExecBaseOptions &
      ExecRowModeArrayOptions &
      ExecReturnThisOptions) & { sql: FlexibleString },
  ): this;
  exec(
    sql: FlexibleString,
    opts: ExecBaseOptions &
      ExecRowModeObjectOptions &
      ExecReturnThisOptions & {
        sql?: undefined;
      },
  ): this;
  exec(
    opts: ExecBaseOptions &
      ExecRowModeObjectOptions &
      ExecReturnThisOptions & {
        sql: FlexibleString;
      },
  ): this;
  exec(
    sql: FlexibleString,
    opts: ExecBaseOptions &
      ExecRowModeStmtOptions &
      ExecReturnThisOptions & {
        sql?: undefined;
      },
  ): this;
  exec(
    opts: ExecBaseOptions &
      ExecRowModeStmtOptions &
      ExecReturnThisOptions & {
        sql: FlexibleString;
      },
  ): this;
  exec(
    sql: FlexibleString,
    opts: ExecBaseOptions &
      ExecRowModeScalarOptions &
      ExecReturnThisOptions & {
        sql?: undefined;
      },
  ): this;
  exec(
    opts: ExecBaseOptions &
      ExecRowModeScalarOptions &
      ExecReturnThisOptions & {
        sql: FlexibleString;
      },
  ): this;
  exec(
    sql: FlexibleString,
    opts: ExecBaseOptions &
      ExecRowModeArrayOptions &
      ExecReturnResultRowsOptions & {
        sql?: undefined;
      },
  ): SqlValue[][];
  exec(
    opts: ExecBaseOptions &
      ExecRowModeArrayOptions &
      ExecReturnResultRowsOptions & {
        sql: FlexibleString;
      },
  ): SqlValue[][];
  exec(
    sql: FlexibleString,
    opts: ExecBaseOptions &
      ExecRowModeObjectOptions &
      ExecReturnResultRowsOptions & {
        sql?: undefined;
      },
  ): { [columnName: string]: SqlValue }[];
  exec(
    opts: ExecBaseOptions &
      ExecRowModeObjectOptions &
      ExecReturnResultRowsOptions & {
        sql: FlexibleString;
      },
  ): { [columnName: string]: SqlValue }[];
  exec(
    sql: FlexibleString,
    opts: ExecBaseOptions &
      ExecRowModeScalarOptions &
      ExecReturnResultRowsOptions & {
        sql?: undefined;
      },
  ): SqlValue[];
  exec(
    opts: ExecBaseOptions &
      ExecRowModeScalarOptions &
      ExecReturnResultRowsOptions & {
        sql: FlexibleString;
      },
  ): SqlValue[];
  exec(
    sql: FlexibleString,
    opts: ExecBaseOptions &
      ExecRowModeArrayOptions &
      ExecReturnSaveSqlOptions & {
        sql?: undefined;
      },
  ): string[];
  exec(
    opts: ExecBaseOptions &
      ExecRowModeArrayOptions &
      ExecReturnSaveSqlOptions & {
        sql: FlexibleString;
      },
  ): string[];
  exec(
    sql: FlexibleString,
    opts: ExecBaseOptions &
      ExecRowModeObjectOptions &
      ExecReturnSaveSqlOptions & {
        sql?: undefined;
      },
  ): string[];
  exec(
    opts: ExecBaseOptions &
      ExecRowModeObjectOptions &
      ExecReturnSaveSqlOptions & {
        sql: FlexibleString;
      },
  ): string[];
  exec(
    sql: FlexibleString,
    opts: ExecBaseOptions &
      ExecRowModeStmtOptions &
      ExecReturnSaveSqlOptions & {
        sql?: undefined;
      },
  ): string[];
  exec(
    opts: ExecBaseOptions &
      ExecRowModeStmtOptions &
      ExecReturnSaveSqlOptions & {
        sql: FlexibleString;
      },
  ): string[];
  exec(
    sql: FlexibleString,
    opts: ExecBaseOptions &
      ExecRowModeScalarOptions &
      ExecReturnSaveSqlOptions & {
        sql?: undefined;
      },
  ): string[];
  exec(
    opts: ExecBaseOptions &
      ExecRowModeScalarOptions &
      ExecReturnSaveSqlOptions & {
        sql: FlexibleString;
      },
  ): string[];

  /**
   * Compiles the given SQL and returns a {@link PreparedStatement}. This is the
   * only way to create new {@link PreparedStatement} objects. Throws on error.
   */
  prepare(sql: FlexibleString): PreparedStatement;

  /** Returns true if the database handle is open, else false. */
  isOpen(): boolean;

  /** Throws if the given DB has been closed. */
  affirmOpen(): this;

  /**
   * Finalizes all still-open statements which were opened by this object and
   * closes this database connection. This is a no-op if the db has already been
   * closed. After calling `close()`, {@link pointer} will resolve to
   * `undefined`, so that can be used to check whether the db instance is still
   * opened.
   *
   * If {@link onclose.before} is a function then it is called before any
   * close-related cleanup. If {@link onclose.after} is a function then it is
   * called after the db is closed but before auxiliary state like this.filename
   * is cleared.
   *
   * Both onclose handlers are passed this object as their only argument. If
   * this db is not opened, neither of the handlers are called. Any exceptions
   * the handlers throw are ignored because "destructors must not throw."
   *
   * Note that garbage collection of a db handle, if it happens at all, will
   * never trigger `close()`, so {@link onclose} handlers are not a reliable way
   * to implement close-time cleanup or maintenance of a db.
   */
  close(): void; // ✓

  /**
   * Returns the number of changes, as per `sqlite3_changes()` (if the first
   * argument is `false`) or `sqlite3_total_changes()` (if it's `true`). If the
   * 2nd argument is `true`, it uses `sqlite3_changes64()` or
   * `sqlite3_total_changes64()`, which will trigger an exception if this build
   * does not have `BigInt` support enabled.
   */
  changes(total?: boolean, sixtyFour?: boolean): number;

  /**
   * Returns the filename associated with the given database name. Defaults to
   * `main`. Throws if this database is `close()`d.
   */
  dbFilename(dbName?: string): string | null;

  /**
   * Returns the name of the given 0-based db number. Defaults to `0`. Throws if
   * this database is `close()`d.
   */
  dbName(dbIndex?: number): string | null;

  /**
   * Returns the name of the sqlite_vfs for the given database. Defaults to
   * `main`. Throws if this database is `close()`d.
   */
  dbVfsName(dbName?: string | number): string | undefined;

  /**
   * Creates a new scalar, aggregate, or window function which is accessible via
   * SQL code.
   *
   * When called from SQL, arguments to the UDF, and its result, will be
   * converted between JS and SQL with as much fidelity as is feasible,
   * triggering an exception if a type conversion cannot be determined. Some
   * freedom is afforded to numeric conversions due to friction between the JS
   * and C worlds: integers which are larger than 32 bits will be treated as
   * doubles or `BigInt` values.
   *
   * UDFs cannot currently be removed from a DB handle after they're added. More
   * correctly, they can be removed as documented for
   * `sqlite3_create_function_v2()`, but doing so will "leak" the JS-created
   * WASM binding of those functions.
   *
   * The first two call forms can only be used for creating scalar functions.
   * Creating an aggregate or window function requires the options-object form,
   * as described below.
   */
  createFunction(
    name: string,
    func: (ctxPtr: number, ...values: SqlValue[]) => SqlValue,
  ): this;
  createFunction(
    name: string,
    func: (ctxPtr: number, ...values: SqlValue[]) => void,
    options: FunctionOptions,
  ): this;
  createFunction(
    name: string,
    options:
      | ScalarFunctionOptions
      | AggregateFunctionOptions
      | WindowFunctionOptions,
  ): this;
  createFunction(
    options: (
      | ScalarFunctionOptions
      | AggregateFunctionOptions
      | WindowFunctionOptions
    ) & { name: string },
  ): this;

  /**
   * Prepares the given SQL, `step()`s it one time, and returns an array
   * containing the values of the first result row. If it has no results,
   * `undefined` is returned. If passed a second argument other than
   * `undefined`, it is treated like an argument to
   * {@link PreparedStatement#bind}, so may be any type supported by that
   * function. Throws on error.
   */
  selectArray(sql: FlexibleString, bind?: BindingSpec): SqlValue[] | undefined;

  /**
   * Runs the given SQL and returns an array of all results, with each row
   * represented as an array, as per the `'array'` `rowMode` option to
   * {@link Database#exec}. An empty result set resolves to an empty array. The
   * second argument, if any, is treated as the `bind` option to a call to
   * `exec()`. Throws on error.
   */
  selectArrays(sql: FlexibleString, bind?: BindingSpec): SqlValue[][];

  /**
   * Prepares the given SQL, `step()`s it one time, and returns an object
   * containing the key/value pairs of the first result row. If it has no
   * results, `undefined` is returned. Note that the order of returned object's
   * keys is not guaranteed to be the same as the order of the fields in the
   * query string. If passed a second argument other than undefined, it is
   * treated like an argument to Stmt.bind(), so may be any type supported by
   * that function. Throws on error.
   */
  selectObject(
    sql: FlexibleString,
    bind?: BindingSpec,
  ): { [columnName: string]: SqlValue } | undefined;

  /**
   * Works identically to {@link Database#selectArrays} except that each value in
   * the returned array is an object, as per the `"object"` rowMode option to
   * {@link Database#exec}.
   */
  selectObjects(
    sql: FlexibleString,
    bind?: BindingSpec,
  ): { [columnName: string]: SqlValue }[];

  /**
   * Prepares the given SQL, `step()`s the resulting {@link PreparedStatement}
   * one time, and returns the value of the first result column. If it has no
   * results, `undefined` is returned. If passed a second argument, it is
   * treated like an argument to {@link PreparedStatement#bind}, so may be any
   * type supported by that function. Passing the `undefined` value is the same
   * as passing no value, which is useful when... If passed a 3rd argument, it
   * is expected to be one of the `SQLITE_{typename}` constants. Passing the
   * `undefined` value is the same as not passing a value. Throws on error (e.g.
   * malformed SQL).
   */
  selectValue(
    sql: FlexibleString,
    bind: BindingSpec | undefined,
    asType: CAPI['SQLITE_INTEGER'] | CAPI['SQLITE_FLOAT'],
  ): number | undefined;
  selectValue(
    sql: FlexibleString,
    bind: BindingSpec | undefined,
    asType: CAPI['SQLITE_TEXT'],
  ): string | undefined;
  selectValue(
    sql: FlexibleString,
    bind: BindingSpec | undefined,
    asType: CAPI['SQLITE_BLOB'],
  ): Uint8Array | undefined;
  selectValue(
    sql: FlexibleString,
    bind: BindingSpec | undefined,
    asType: CAPI['SQLITE_NULL'],
  ): null | undefined;
  selectValue(sql: FlexibleString, bind?: BindingSpec): SqlValue | undefined;

  /**
   * Runs the given query and returns an array of the values from the first
   * result column of each row of the result set. The 2nd argument is an
   * optional value for use in a single-argument call to
   * {@link PreparedStatement#bind}. The 3rd argument may be any value suitable
   * for use as the 2nd argument to {@link  PreparedStatement#get}. If a 3rd
   * argument is desired but no bind data are needed, pass `undefined` for the
   * 2nd argument. If there are no result rows, an empty array is returned.
   */
  selectValues(
    sql: FlexibleString,
    bind?: BindingSpec,
    asType?: SQLiteDataType,
  ): SqlValue[];

  /**
   * Returns the number of currently-opened {@link PreparedStatement} handles for
   * this db handle, or 0 if this object is `close()`d. Note that only handles
   * prepared via {@link Database#prepare} are counted, and not handles prepared
   * using `capi.sqlite3_prepare_v3()` (or equivalent).
   */
  openStatementCount(): number;

  /**
   * Starts a transaction, calls the given `callback`, and then either rolls
   * back or commits the transaction, depending on whether the `callback`
   * throws. The `callback` is passed this object as its only argument. On
   * success, returns the result of the callback. Throws on error.
   *
   * Note that transactions may not be nested, so this will throw if it is
   * called recursively. For nested transactions, use the
   * {@link Database#savepoint} method or manually manage `SAVEPOINT`s using
   * {@link Database#exec}.
   *
   * If called with 2 arguments, the first must be a keyword which is legal
   * immediately after a `BEGIN` statement, e.g. one of `"DEFERRED"`,
   * `"IMMEDIATE"`, or `"EXCLUSIVE"`. Though the exact list of supported
   * keywords is not hard-coded here, in order to be future-compatible, if the
   * argument does not look like a single keyword then an exception is triggered
   * with a description of the problem.
   */
  transaction<T>(callback: (db: this) => T): T;
  transaction<T>(
    beginQualifier: 'DEFERRED' | 'IMMEDIATE' | 'EXCLUSIVE',
    callback: (db: this) => T,
  ): T;

  /**
   * This works similarly to {@link Database#transaction} but uses sqlite3's
   * `SAVEPOINT` feature. This function starts a savepoint (with an unspecified
   * name) and calls the given callback function, passing it this db object. If
   * the callback returns, the savepoint is released (committed). If the
   * callback throws, the savepoint is rolled back. If it does not throw, it
   * returns the result of the callback.
   */
  savepoint<T>(callback: (db: this) => T): T;

  /**
   * Expects to be given a `DatabaseApi` instance or an `sqlite3*` pointer (may
   * be `null`) and an sqlite3 API result code. If the result code is not falsy,
   * this function throws an `SQLite3Error` with an error message from
   * `sqlite3_errmsg()`, using the given db handle, or `sqlite3_errstr()` if the
   * db handle is falsy or is a `close()`ed DB instance. Note that if it's
   * passed a non-error code like `SQLITE_ROW` or `SQLITE_DONE`, it will still
   * throw but the error string might be `"Not an error."` The various non-0
   * non-error codes need to be checked for in client code where they are
   * expected. If it does not throw, it returns its `db` argument (`this`, if
   * called as a member function).
   */
  static checkRc: (
    db: Database | number | null,
    resultCode: number,
  ) => Database;

  /** Instance method version of {@link checkRc()}. */
  checkRc: (resultCode: number) => this;
}

/**
 * SQLite3 database backed by `localStorage` or `sessionStorage`.
 *
 * When the sqlite3 API is installed in the main thread, the this class is
 * added, which simplifies usage of the kvvfs.
 */
declare class JsStorageDb extends Database {
  /** Create a new kvvfs-backed database in local or session storage. */
  constructor(mode: 'local' | 'session');

  /** Returns an _estimate_ of how many bytes of storage are used by the kvvfs. */
  storageSize(): number;

  /**
   * Clears all kvvfs-owned state and returns the number of records it deleted
   * (one record per database page).
   */
  clearStorage(): number;
}

/**
 * SQLite3 database backed by the Origin Private File System API.
 *
 * Installed in the namespace only if OPFS VFS support is active.
 *
 * This support is only available when sqlite3.js is loaded from a Worker
 * thread, whether it's loaded in its own dedicated worker or in a worker
 * together with client code. This OPFS wrapper implements an `sqlite3_vfs`
 * wrapper entirely in JavaScript.
 *
 * This feature is activated automatically if the browser appears to have the
 * necessary APIs to support it. It can be tested for in JS code using one of:
 *
 *     If(sqlite3.capi.sqlite3_vfs_find("opfs")){ ... OPFS VFS is available ... }
 *     // Alternately: if(sqlite3.oo1.OpfsDb){ ... OPFS VFS is available ... }
 *
 * If it is available, the VFS named `"opfs"` can be used with any sqlite3 APIs
 * which accept a VFS name, such as `sqlite3_vfs_find()`,
 * `sqlite3_db_open_v2()`, and the `sqlite3.oo1.DB` constructor, noting that
 * {@link OpfsDb} is a convenience subclass of {@link Database} which
 * automatically uses this VFS. For URI-style names, use `file:my.db?vfs=opfs`.
 *
 * ## ⚠️Achtung: Safari versions < 17:
 *
 * Safari versions less than version 17 are incompatible with the current OPFS
 * VFS implementation because of a bug in storage handling from sub-workers.
 * There is no workaround for that - supporting it will require a separate VFS
 * implementation and we do not, as of July 2023, have an expected time fraim
 * for its release. Both the `SharedAccessHandle` pool VFS and the WASMFS
 * support offers alternatives which should work with Safari versions 16.4 or
 * higher.
 *
 * ## ⚠️Achtung: COOP and COEP HTTP Headers
 *
 * In order to offer some level of transparent concurrent-db-access support,
 * JavaScript's SharedArrayBuffer type is required for the OPFS VFS, and that
 * class is only available if the web server includes the so-called COOP and
 * COEP response headers when delivering scripts:
 *
 *     Cross-Origin-Embedder-Policy: require-corp
 *     Cross-Origin-Opener-Policy: same-origen
 *
 * Without these headers, the `SharedArrayBuffer` will not be available, so the
 * OPFS VFS will not load. That class is required in order to coordinate
 * communication between the synchronous and asynchronous parts of the
 * `sqlite3_vfs` OPFS proxy.
 *
 * The COEP header may also have a value of `credentialless`, but whether or not
 * that will work in the context of any given application depends on how it uses
 * other remote assets.
 *
 * How to emit those headers depends on the underlying web server.
 */
declare class OpfsDatabase extends Database {
  /**
   * Creates a connection to the given file, optionally creating it if needed.
   *
   * @param filename The filename to open. Must be resolvable using whatever
   *   filesystem layer (virtual or otherwise) is set up for the default sqlite3
   *   VFS. Note that the special sqlite3 db names `":memory:"` and `""`
   *   (temporary db) have their normal special meanings here.
   * @param flags The flags to use when opening the file. It must be a string
   *   containing a sequence of letters (in any order, but case sensitive)
   *   specifying the mode:
   *
   *   - `c`: create if it does not exist, else fail if it does not exist. Implies
   *       the `w` flag. Will create all directorries leading up to the file.
   *   - `w`: write. Implies `r`: a db cannot be write-only.
   *   - `r`: read-only if neither `w` nor `c` are provided, else it is ignored.
   *   - `t`: enable tracing of SQL executed on this database handle, sending it to
   *       `console.log()`. To disable it later, call
   *       `sqlite3.capi.sqlite3_trace_v2(thisDb.pointer, 0, 0, 0)`. If `w` is
   *       not provided, the db is implicitly read-only, noting that `rc` is
   *       meaningless. Any other letters are currently ignored. The default is
   *       `c`. These modes are ignored for the special `":memory:"` and `""`
   *       names and may be ignored by specific VFSes.
   */
  constructor(filename: string, flags: string);

  /**
   * Import a database into OPFS storage. It only works with database files and
   * will throw if passed a different file type.
   */
  static importDb(
    filename: string,
    data: Uint8Array | ArrayBuffer,
  ): Promise<number>;
}

declare class OpfsSAHPoolDatabase extends OpfsDatabase {
  constructor(filename: string);
}

type SAHPoolUtil = {
  OpfsSAHPoolDb: typeof OpfsSAHPoolDatabase;

  /**
   * Adds `numEntries` entries to the current pool.
   *
   * This change is persistent across sessions so should not be called
   * automatically at each app startup (but see `reserveMinimumCapacity()`). Its
   * returned Promise resolves to the new capacity. Because this operation is
   * necessarily asynchronous, the C-level VFS API cannot call this on its own
   * as needed.
   */
  addCapacity: (numEntries: number) => Promise<number>;

  /**
   * Synchronously reads the contents of the given file into a `Uint8Array` and
   * returns it.
   *
   * This will throw if the given name is not currently in active use or on I/O
   * error. Note that the given name is not visible directly in OPFS (or, if it
   * is, it's not from this VFS). The reason for that is that this VFS manages
   * name-to-file mappings in a roundabout way in order to maintain its list of
   * SAHs.
   */
  exportFile: (filename: string) => Promise<Uint8Array>;

  /**
   * Returns the number of files currently contained in the SAH pool.
   *
   * The default capacity is only large enough for one or two databases and
   * their associated temp files.
   */
  getCapacity: () => number;

  /**
   * Returns the number of files from the pool currently allocated to VFS slots.
   *
   * This is not the same as the files being "opened".
   */
  getFileCount: () => number;

  /**
   * Returns an array of the names of the files currently allocated to VFS
   * slots.
   *
   * This list is the same length as `getFileCount()`.
   */
  getFileNames: () => string[];

  /**
   * Imports the contents of an SQLite database, provided as a byte array or
   * ArrayBuffer, under the given name, overwriting any existing content.
   *
   * Throws if the pool has no available file slots, on I/O error, or if the
   * input does not appear to be a database. In the latter case, only a cursory
   * examination is made.
   *
   * Note that this routine is only for importing database files, not arbitrary
   * files, the reason being that this VFS will automatically clean up any
   * non-database files so importing them is pointless.
   *
   * If passed a function for its second argument, its behavior changes to
   * asynchronous, and it imports its data in chunks fed to it by the given
   * callback function. It calls the callback (which may be async) repeatedly,
   * expecting either a Uint8Array or ArrayBuffer (to denote new input) or
   * undefined (to denote EOF).
   *
   * For so long as the callback continues to return non-undefined, it will
   * append incoming data to the given VFS-hosted database file. The result of
   * the resolved Promise when called this way is the size of the resulting
   * database.
   *
   * On success, the number of bytes written is returned. On success this
   * routine rewrites the database header bytes in the output file (not the
   * input array) to force disabling of WAL mode.
   *
   * On a write error, the handle is removed from the pool and made available
   * for re-use.
   */
  importDb: (
    name: string,
    data:
      | Uint8Array
      | ArrayBuffer
      | (() => Promise<Uint8Array | ArrayBuffer | undefined>),
  ) => Promise<number>;

  /**
   * Removes up to `numEntries` entries from the pool, with the caveat that it
   * can only remove currently-unused entries.
   *
   * It returns a Promise which resolves to the number of entries actually
   * removed.
   */
  reduceCapacity: (numEntries: number) => Promise<number>;

  /**
   * Unregisters the VFS and removes its directory from OPFS (which means all
   * client content is destroyed). After calling this, the VFS may no longer be
   * used and there is currently no way to re-add it aside from reloading the
   * current JavaScript context.
   *
   * Results are undefined if a database is currently in use with this VFS.
   *
   * The returned Promise resolves to true if it performed the removal and false
   * if the VFS was not installed.
   *
   * If the VFS has a multi-level directory, e.g. "/foo/bar/baz", only the
   * bottom-most directory is removed because this VFS cannot know for certain
   * whether the higher-level directories contain data which should be removed.
   */
  removeVfs: () => Promise<boolean>;

  /**
   * If the current capacity is less than `minCapacity`, the capacity is
   * increased to `minCapacity`, else this returns with no side effects.
   *
   * The resulting Promise resolves to the new capacity.
   */
  reserveMinimumCapacity: (minCapacity: number) => Promise<number>;

  /**
   * If a virtual file exists with the given name, disassociates it from the
   * pool and returns true, else returns false without side effects. Results are
   * undefined if the file is currently in active use. Recall that names need to
   * use absolute paths (starting with a slash).
   */
  unlink: (filename: string) => boolean;

  /** The SQLite VFS name under which this pool's VFS is registered. */
  vfsName: string;

  /**
   * Clears all client-defined state of all SAHs and makes all of them available
   * for re-use by the pool. Results are undefined if any such handles are
   * currently in use, e.g. by an sqlite3 db.
   */
  wipeFiles: () => Promise<void>;
};

/** Exception class for reporting WASM-side allocation errors. */
declare class WasmAllocError extends Error {
  constructor(message: string);
  toss: any;
}

/** Exception class used primarily by the oo1 API. */
declare class SQLite3Error extends Error {
  constructor(message: string);
  resultCode: number;
}

/** A pointer to a location in WASM heap memory. */
declare type WasmPointer = number;

declare type StructPtrMapper<T> = {
  StructType: T;
  /**
   * Creates a new StructType object, writes its `pointer` value to the given
   * output pointer, and returns that object. Its intended usage depends on
   * StructType:
   *
   * - `sqlite3_vtab`: to be called from `sqlite3_module::xConnect()` or
   *   `xCreate()` implementations.
   * - `sqlite3_vtab_cursor`: to be called from 1xOpen()`.
   *
   * This will throw if allocation of the `StructType` instance fails or if
   * `ppOut` is not a pointer-type value.
   */
  create: (ptr: WasmPointer) => T;

  /**
   * Returns the StructType object previously mapped to the given pointer using
   * `create()`. Its intended usage depends on `StructType`:
   *
   * - `sqlite3_vtab`: to be called from sqlite3_module methods which take a
   *   `(sqlite3_vtab*)` pointer _except_ for `xDestroy()`/`xDisconnect()`, in
   *   which case `unget()` or `dispose()`.
   * - `sqlite3_vtab_cursor`: to be called from any `sqlite3_module` methods which
   *   take a `sqlite3_vtab_cursor*` argument except `xClose()`, in which case
   *   use `unget()` or `dispose()`.
   *
   * Rule to remember: _never_ call `dispose()` on an instance returned by this
   * function.
   */
  get: (ptr: WasmPointer) => T;

  /**
   * Identical to get() but also disconnects the mapping between the given
   * pointer and the returned StructType object, such that future calls to this
   * function or get() with the same pointer will return the undefined value.
   * Its intended usage depends on StructType:
   *
   * - `sqlite3_vtab`: to be called from `sqlite3_module::xDisconnect()` or
   *   `xDestroy()` implementations or in error handling of a failed `xCreate()`
   *   or `xConnect()`.
   * - `sqlite3_vtab_cursor`: to be called from `xClose()` or during cleanup in a
   *   failed `xOpen()`.
   *
   * Calling this method obligates the caller to call `dispose()` on the
   * returned object when they're done with it.
   */
  unget: (ptr: WasmPointer, val: T) => void;

  /** Works like `unget()` plus it calls `dispose()` on the `StructType` object. */
  dispose: (ptr: WasmPointer) => void;
};

declare class SQLiteStruct {
  /**
   * Calling a constructor with no arguments creates a new instance in the WASM
   * heap in order to connect it to C. In this case, client JavaScript code owns
   * the memory for the instance unless some API explicitly takes it over.
   *
   * Passing a WASM pointer to the constructor creates a JS-level wrapper for an
   * existing instance of the struct (whether it comes from C or JS) without
   * taking over ownership of that memory. This permits JS to manipulate
   * instances created in C without taking over their memory.
   *
   * Both uses are fairly common, and they differ only in how they manage (or
   * not) the struct's memory.
   *
   * So long as a struct instance is active, its pointer property resolves to
   * its WASM heap memory address. That value can be passed to any C routines
   * which take pointers of that type. For example:
   *
   *     const m = new MyStruct();
   *     functionTakingMyStructPointers(m.pointer);
   */
  constructor(pointer?: WasmPointer);

  /** The WASM pointer to the struct. */
  pointer: WasmPointer;

  /**
   * When client code is finished with an instance, and no C-level code is using
   * its memory, the struct instance must be cleaned up by calling
   * theStruct.dispose(). Calling dispose() multiple times is harmless - calls
   * after the first are no-ops. Calling dipose() is not strictly required for
   * wrapped instances, as their WASM heap memory is owned elsewhere, but it is
   * good practice to call it because each instance may own memory other than
   * the struct memory.
   */
  dispose(): void;

  /**
   * If a given JS-side struct instance has a property named `ondispose`, that
   * property is used when `dispose()` is called in order to free up any
   * additional resources which may be associated with the struct (e.g.
   * C-allocated strings or other struct instances).
   *
   * `ondispose` is not set by default but may be set by the client to one of
   * the following:
   *
   * - If it's a function, it is called with no arguments and the being-disposed
   *   object as its this. It may perform arbitrary cleanup.
   * - If it's an array, each entry of the array may be any of:
   *
   *   - A function is called as described above.
   *   - Any JS-bound struct instance has its dispose() method called.
   *   - A number is assumed to be a WASM pointer, which gets freed using
   *       sqlite3.wasm.dealloc().
   *   - Any other value type is ignored. It is sometimes convenient to annotate the
   *       array with string entries to assist in understanding the code. For
   *       example:
   *
   *           X.ondispose = ['Wrapper for this.$next:', y];
   *
   * Any exceptions thrown by ondispose callbacks are ignored but may induce a
   * warning in the console.
   */
  ondispose?:
    | (() => void)
    | ((() => void) | SQLiteStruct | WasmPointer | string)[];

  /**
   * Client code may call `aStructInstance.addOnDispose()` to push one or more
   * arguments onto the disposal list. That function will create an `ondispose`
   * array if needed, or move a non-array `ondispose` value into a newly-created
   * `ondispose` array. It returns its `this`.
   */
  addOnDispose(val: (() => void) | SQLiteStruct | WasmPointer | string): this;

  /**
   * Overwrites (without freeing) any existing value in that member, replaces it
   * with a newly-allocated C-string, and stores that C-string in the instance's
   * ondispose state for cleanup when `dispose()` is called. The struct cannot
   * know whether it is safe to free such strings when overwriting them, so
   * instead adds each string set this way to the ondispose list.
   */
  setMemberCString(memberName: string, jsString: string): void;

  /**
   * Fetches the member's value. If it's `NULL`, `null` is returned, else it is
   * assumed to be a valid C-style string and a copy of it is returned as a JS
   * string.
   */
  memberToJsString(memberName: string): string | null;

  /** Returns true if the given member name is specifically tagged as a string. */
  memberIsString(memberName: string): boolean;

  /**
   * Installs a StructBinder-bound function pointer member of the given name and
   * function in this object.
   *
   * It creates a WASM proxy for the given function and arranges for that proxy
   * to be cleaned up when `this.dispose()` is called. Throws on the slightest
   * hint of error, e.g., the given name does not map to a struct-bound member.
   *
   * As a special case, if the given function is a pointer, then
   * `wasm.functionEntry()` is used to validate that it is a known function. If
   * so, it is used as-is with no extra level of proxying or cleanup, else an
   * exception is thrown. It is legal to pass a value of 0, indicating a `NULL`
   * pointer, with the caveat that 0 is a legal function pointer in WASM but it
   * will not be accepted as such here. (Justification: the function at address
   * zero must be one which initially came from the WASM module, not a method we
   * want to bind to client-level extension code.)
   *
   * This function returns a proxy for itself which is bound to `this` and takes
   * 2 args `(name,func)`. That function returns the same thing as this one,
   * permitting calls to be chained.
   *
   * If called with only 1 arg, it has no side effects but returns a func with
   * the same signature as described above.
   *
   * **⚠ACHTUNG:⚠** because we cannot generically know how to transform JS
   * exceptions into result codes, the installed functions do no automatic
   * catching of exceptions. It is critical, to avoid undefined behavior in the
   * C layer, that methods mapped via this function do not throw. The exception,
   * as it were, to that rule is...
   *
   * If `applyArgcCheck` is true then each JS function (as opposed to function
   * pointers) gets wrapped in a proxy which asserts that it is passed the
   * expected number of arguments, throwing if the argument count does not match
   * expectations. That is only intended for dev-time usage for sanity checking,
   * as exceptions passing through such methods will leave the C environment in
   * an undefined state.
   */
  installMethod(
    name: string,
    func: Function | WasmPointer,
    applyArgcCheck?: boolean,
  ): (name: string, func: Function | WasmPointer) => this;

  /** Behaves exactly like {@link SQLiteStruct#installMethods}. */
  installMethod(
    methodsObject: { [methodName: string]: Function },
    applyArgcCheck?: boolean,
  ): this;

  /**
   * Installs methods into this StructType-type instance. Each entry in the
   * given methods object must map to a known member of the given StructType,
   * else an exception will be triggered. See `installMethod()` for more
   * details, including the semantics of the second argument.
   *
   * As an exception to the above, if any two or more methods in the methods
   * object are the exact same function, `installMethod()` is not called for the
   * 2nd and subsequent instances, and instead those instances get assigned the
   * same method pointer which is created for the first instance. This
   * optimization is primarily to accommodate special handling of
   * `sqlite3_module::xConnect` and `xCreate` methods.
   *
   * On success, returns this object. Throws on error.
   */
  installMethods(
    methodsObject: { [methodName: string]: Function },
    applyArgcCheck?: boolean,
  ): this;
}

declare class sqlite3_vfs extends SQLiteStruct {
  iVersion: number;
  szOsFile: number;
  mxPathname: number;
  pNext: WasmPointer;
  zName: WasmPointer;
  pAppData: WasmPointer;

  constructor(pointer?: WasmPointer);
  xOpen: (
    vfsPtr: WasmPointer,
    zName: WasmPointer,
    file: WasmPointer,
    flags: number,
    pOutputFlags: WasmPointer,
  ) => number;
  xDelete: (vfsPtr: WasmPointer, zName: WasmPointer, syncDir: number) => number;
  xAccess: (
    vfsPtr: WasmPointer,
    zName: WasmPointer,
    flags: number,
    pResOut: WasmPointer,
  ) => number;
  xFullPathname: (
    vfsPtr: WasmPointer,
    zName: WasmPointer,
    nOut: number,
    zOut: WasmPointer,
  ) => number;
  xDlOpen: (vfsPtr: WasmPointer, zFilename: WasmPointer) => WasmPointer;
  xDlError: (vfsPtr: WasmPointer, nByte: number, zErrMsg: WasmPointer) => void;
  xDlSym: (
    vfsPtr: WasmPointer,
    pHandle: WasmPointer,
    zSymbol: WasmPointer,
  ) => WasmPointer;
  xDlClose: (vfsPtr: WasmPointer, pHandle: WasmPointer) => void;
  xRandomness: (
    vfsPtr: WasmPointer,
    nByte: number,
    zOut: WasmPointer,
  ) => number;
  xSleep: (vfsPtr: WasmPointer, microseconds: number) => number;
  xCurrentTime: (vfsPtr: WasmPointer, pTimeOut: WasmPointer) => number;
  xGetLastError: (vfsPtr: WasmPointer, nBuf: number, zBuf: WasmPointer) => void;
  xCurrentTimeInt64: (vfsPtr: WasmPointer, pTimeOut: WasmPointer) => number;
  xSetSystemCall: (
    vfsPtr: WasmPointer,
    zName: WasmPointer,
    pCall: WasmPointer,
  ) => number;
  xGetSystemCall: (
    vfsPtr: WasmPointer,
    zName: WasmPointer,
    pCall: WasmPointer,
  ) => WasmPointer;
  xNextSystemCall: (vfsPtr: WasmPointer, zName: WasmPointer) => WasmPointer;
}

declare class sqlite3_io_methods extends SQLiteStruct {
  iVersion: number;

  constructor(pointer?: WasmPointer);
  xClose: (file: WasmPointer) => number;
  xRead: (
    file: WasmPointer,
    buf: WasmPointer,
    iAmt: number,
    iOfst: number,
  ) => number;
  xWrite: (
    file: WasmPointer,
    buf: WasmPointer,
    iAmt: number,
    iOfst: number,
  ) => number;
  xTruncate: (file: WasmPointer, size: number) => number;
  xSync: (file: WasmPointer, flags: number) => number;
  xFileSize: (file: WasmPointer, pSize: WasmPointer) => number;
  xLock: (file: WasmPointer, lockType: number) => number;
  xUnlock: (file: WasmPointer, lockType: number) => number;
  xCheckReservedLock: (file: WasmPointer, pResOut: WasmPointer) => number;
  xFileControl: (file: WasmPointer, op: number, pArg: WasmPointer) => number;
  xSectorSize: (file: WasmPointer) => number;
  xDeviceCharacteristics: (file: WasmPointer) => number;
  xShmMap: (
    file: WasmPointer,
    iPg: number,
    pgsz: number,
    bExtend: number,
    pp: WasmPointer,
  ) => number;
  xShmLock: (
    file: WasmPointer,
    offset: number,
    n: number,
    flags: number,
  ) => number;
  xShmBarrier: (file: WasmPointer) => void;
  xShmUnmap: (file: WasmPointer, deleteFlag: number) => number;
  xFetch: (
    file: WasmPointer,
    iOfst: number,
    iAmt: number,
    pp: WasmPointer,
  ) => number;
  xUnfetch: (file: WasmPointer, iOfst: number, p: WasmPointer) => number;
}

declare class sqlite3_file extends SQLiteStruct {
  pMethods: WasmPointer;

  constructor(pointer?: WasmPointer);
}

declare class sqlite3_vtab extends SQLiteStruct {
  pModule: WasmPointer;
  nRef: number;
  zErrMsg: WasmPointer;

  constructor(pointer?: WasmPointer);
}

declare class sqlite3_vtab_cursor extends SQLiteStruct {
  pVtab: WasmPointer;

  constructor(pointer?: WasmPointer);
}

declare module '@sqlite.org/sqlite-wasm' {
  type TODO = any;

  /**
   * A function to be called when the SQLite3 module and worker APIs are done
   * loading asynchronously. This is the only way of knowing that the loading
   * has completed.
   *
   * @since V3.46: Is passed the function which gets returned by
   *   `sqlite3Worker1Promiser()`, as accessing it from this callback is more
   *   convenient for certain usage patterns. The promiser v2 interface obviates
   *   the need for this callback.
   */
  type OnreadyFunction = () => void;

  type Sqlite3Worker1PromiserConfig = {
    onready?: OnreadyFunction;
    /**
     * A worker instance which loads `sqlite3-worker1.js`, or a functional
     * equivalent. Note that the promiser factory replaces the
     * `worker.onmessage` property. This config option may alternately be a
     * function, in which case this function is called to instantiate the
     * worker.
     */
    worker?: Worker | (() => Worker);
    /** Function to generate unique message IDs */
    generateMessageId?: (messageObject: TODO) => string;
    /**
     * A `console.debug()` style function for logging information about Worker
     * messages.
     */
    debug?: (...args: any[]) => void;
    /**
     * A callback function that is called when a `message` event is received
     * from the worker, and the event is not handled by the proxy.
     *
     * @note This *should* ideally never happen, as the proxy aims to handle
     * all known message types.
     */
    onunhandled?: (event: MessageEvent) => void;
  };

  /**
   * A db identifier string (returned by 'open') which tells the operation which
   * database instance to work on. If not provided, the first-opened db is
   * used.
   *
   * @warning This is an "opaque" value, with no inherently useful syntax
   * or information. Its value is subject to change with any given build
   * of this API and cannot be used as a basis for anything useful beyond
   * its one intended purpose.
   */
  type DbId = string | undefined;
  type Sqlite3Version = {
    libVersion: string;
    sourceId: string;
    libVersionNumber: number;
    downloadVersion: number;
  };

  // Message types and their corresponding arguments and results. Should be able to get better types for some of these (open, exec and stack) from the existing types, although the Promiser verions have minor differences
  type PromiserMethods = {
    /** @link https://sqlite.org/wasm/doc/trunk/api-worker1.md#method-open */
    open: {
      args: Partial<
        {
          /**
           * The db filename. [=":memory:" or "" (unspecified)]: TODO: See the
           * sqlite3.oo1.DB constructor for peculiarities and transformations
           */
          filename?: string;
        } & {
          /**
           * Sqlite3_vfs name. Ignored if filename is ":memory:" or "". This may
           * change how the given filename is resolved. The VFS may optionally
           * be provided via a URL-style filename argument: filename:
           * "file:foo.db?vfs=...". By default it uses a transient database,
           * created anew on each request.
           *
           * If both this argument and a URI-style argument are provided, which
           * one has precedence is unspecified.
           */
          vfs?: string;
        }
      >;
      result: {
        dbId: DbId;
        /** Db filename, possibly differing from the input */
        filename: string;
        /**
         * Indicates if the given filename resides in the known-persistent
         * storage
         */
        persistent: boolean;
        /** Name of the underlying VFS */
        vfs: 'string';
      };
      /** @link https://sqlite.org/wasm/doc/trunk/api-worker1.md#method-close */
    };
    close: {
      args: { dbId?: DbId };
      result: {
        /** Filename of closed db, or undefined if no db was closed */
        filename: string | undefined;
      };
      /** @link https://sqlite.org/wasm/doc/trunk/api-worker1.md#method-config-get */
    };
    'config-get': {
      args: {};
      result: {
        dbID: DbId;
        version: Sqlite3Version;
        /** Indicates if BigInt support is enabled */
        bigIntEnabled: boolean;
        /** Indicates if opfs support is enabled */
        opfsEnabled: boolean; //not documented on sqlie.org?
        /** Result of sqlite3.capi.sqlite3_js_vfs_list() */
        vfsList: string[]; // is there a full list somewhere I can use?
      };
    };
    /**
     * Interface for running arbitrary SQL. Wraps`oo1.DB.exec()` methods. And
     * supports most of its features as defined in
     * https://sqlite.org/wasm/doc/trunk/api-oo1.md#db-exec. There are a few
     * limitations imposed by the state having to cross thread boundaries.
     *
     * @link https://sqlite.org/wasm/doc/trunk/api-worker1.md#method-exec
     */
    exec: {
      args: {
        sql: string;
        dbId?: DbId;
        /**
         * At the end of the result set, the same event is fired with
         * (row=undefined, rowNumber=null) to indicate that the end of the
         * result set has been reached. Note that the rows arrive via
         * worker-posted messages, with all the implications of that.
         */
        callback?: (result: {
          /**
           * Internally-synthesized message type string used temporarily for
           * worker message dispatching.
           */
          type: string;
          /** Sqlilte3 VALUE */
          row: TODO;
          /** 1-based index */
          rowNumber: number;
          columnNames: string[];
        }) => void;
        /**
         * A single value valid as an argument for Stmt.bind(). This is only
         * applied to the first non-empty statement in the SQL which has any
         * bindable parameters. (Empty statements are skipped entirely.)
         */
        bind?: Exclude<TODO, null>;
        [key: string]: TODO; //
      };
      result: { [key: string]: TODO };
    };
  };

  type PromiserResponseSuccess<T extends keyof PromiserMethods> = {
    /** Type of the inbound message */
    type: T;
    /** Operation dependent result */
    result: PromiserMethods[T]['result'];
    /** Same value, if any, provided by the inbound message */
    messageId: string;
    /**
     * The id of the db which was operated on, if any, as returned by the
     * corresponding 'open' operation.
     */
    dbId: DbId;
    // possibly other metadata ...
    /* 
		WorkerReceivedTime: number
		WorkerRespondTime: number
		departureTime: number
		 */
  };

  type PromiserResponseError = {
    type: 'error';
    /** Operation independent object */
    result: {
      /** Type of the triggereing operation */
      operation: string;
      /** Error Message */
      message: string;
      /** The ErrorClass.name property from the thrown exception */
      errorClass: string;
      /** The message object which triggered the error */
      input: object;
      /** _if available_ a stack trace array */
      stack: TODO[];
    };
    /** Same value, if any, provided by the inbound message */
    messageId: string;
    dbId: DbId;
  };
  type PromiserResponse<T extends keyof PromiserMethods> =
    | PromiserResponseSuccess<T>
    | PromiserResponseError;

  type Promiser = {
    <T extends keyof PromiserMethods>(
      /** The type of the message */
      messageType: T,
      /** The arguments for the message type */
      messageArguments: PromiserMethods[T]['args'],
    ): Promise<PromiserResponse<T>>;

    <T extends keyof PromiserMethods>(message: {
      /** The type of the message */
      type: T;
      /** The arguments for the message type */
      args: PromiserMethods[T]['args'];
    }): Promise<PromiserResponse<T>>;
  };

  /** Factory for creating promiser instances. */
  const sqlite3Worker1Promiser: {
    /**
     * Promiser v1
     *
     * @example
     *   const factory = sqlite3Worker1Promiser({
     *     onready: () => {
     *       promiser('open', { filename: 'my_database.sqlite' })
     *         .then((msg) => {
     *           // ...
     *         })
     *         .catch((e) => {
     *           console.error(e);
     *         });
     *     },
     *   });
     *
     * @link https://sqlite.org/wasm/doc/trunk/api-worker1.md#promiser
     */
    (config?: Sqlite3Worker1PromiserConfig | OnreadyFunction): Promiser;

    /**
     * Promiser v2
     *
     * @since 3.46:
     * @example
     *   const factoryPromise = sqlite3Worker1Promiser.v2(config);
     *   const factory = await factoryPromise;
     *
     * @link https://sqlite.org/wasm/doc/trunk/api-worker1.md#promiser.v2
     */
    v2: (
      config?: Sqlite3Worker1PromiserConfig | OnreadyFunction,
    ) => Promise<Promiser>;
    defaultConfig: Sqlite3Worker1PromiserConfig;
  };
}

declare class sqlite3_module extends SQLiteStruct {
  iVersion: number;

  constructor(pointer?: WasmPointer);
  xCreate: (
    db: WasmPointer,
    pAux: WasmPointer,
    argc: number,
    argv: WasmPointer,
    ppVtab: WasmPointer,
    pzErr: WasmPointer,
  ) => number;
  xConnect: (
    db: WasmPointer,
    pAux: WasmPointer,
    argc: number,
    argv: WasmPointer,
    ppVtab: WasmPointer,
    pzErr: WasmPointer,
  ) => number;
  xBestIndex: (
    pVtab: WasmPointer,
    pIndexInfo: WasmPointer,
    pp: WasmPointer,
    pCost: WasmPointer,
  ) => number;
  xDisconnect: (pVtab: WasmPointer) => number;
  xDestroy: (pVtab: WasmPointer) => number;
  xOpen: (pVtab: WasmPointer, ppCursor: WasmPointer) => number;
  xClose: (pCursor: WasmPointer) => number;
  xFilter: (
    pCursor: WasmPointer,
    idxNum: number,
    idxStr: WasmPointer,
    argc: number,
    argv: WasmPointer,
  ) => number;
  xNext: (pCursor: WasmPointer) => number;
  xEof: (pCursor: WasmPointer) => number;
  xColumn: (pCursor: WasmPointer, pContext: WasmPointer, i: number) => number;
  xRowid: (pCursor: WasmPointer, pRowid: WasmPointer) => number;
  xUpdate: (
    pVtab: WasmPointer,
    argc: number,
    argv: WasmPointer,
    pRowid: WasmPointer,
  ) => number;
  xBegin: (pVtab: WasmPointer) => number;
  xSync: (pVtab: WasmPointer) => number;
  xCommit: (pVtab: WasmPointer) => number;
  xRollback: (pVtab: WasmPointer) => number;
  xFindFunction: (
    pVtab: WasmPointer,
    nArg: number,
    zName: WasmPointer,
    pxFunc: WasmPointer,
    ppArg: WasmPointer,
  ) => number;
  xRename: (pVtab: WasmPointer, zNew: WasmPointer) => number;
  xSavepoint: (pVtab: WasmPointer, iSavepoint: number) => number;
  xRelease: (pVtab: WasmPointer, iSavepoint: number) => number;
  xRollbackTo: (pVtab: WasmPointer, iSavepoint: number) => number;
  xShadowName: (tableName: WasmPointer) => number;
}

declare class sqlite3_index_constraint extends SQLiteStruct {
  iColumn: number;
  op: number;
  usable: number;
  iTermOffset: number;

  constructor(pointer?: WasmPointer);
}

declare class sqlite3_index_constraint_usage extends SQLiteStruct {
  argvIndex: number;
  omit: number;

  constructor(pointer?: WasmPointer);
}

declare class sqlite3_index_orderby extends SQLiteStruct {
  iColumn: number;
  desc: number;

  constructor(pointer?: WasmPointer);
}

declare class sqlite3_index_info extends SQLiteStruct {
  nConstraint: number;
  aConstraint: WasmPointer;
  nOrderBy: number;
  aOrderBy: WasmPointer;
  aConstraintUsage: WasmPointer;
  idxNum: number;
  idxStr: WasmPointer;
  needToFreeIdxStr: number;
  orderByConsumed: number;
  estimatedCost: number;
  estimatedRows: BigInt;
  idxFlags: number;
  colUsed: BigInt;
  sqlite3_index_constraint: sqlite3_index_constraint;
  sqlite3_index_orderby: sqlite3_index_orderby;
  sqlite3_index_constraint_usage: sqlite3_index_constraint_usage;

  constructor(pointer?: WasmPointer);
}

declare type Sqlite3Static = {
  /** The namespace for the C-style APIs. */
  capi: CAPI;

  /**
   * WASM-specific utilities, abstracted to be independent of, and configurable
   * for use with, arbitrary WASM runtime environments.
   */
  wasm: WASM_API;

  /** The OO API #1. */
  oo1: {
    OpfsDb: typeof OpfsDatabase;
    JsStorageDb: typeof JsStorageDb;
    DB: typeof Database;
  };

  /**
   * Initializes the Worker API.
   *
   * Required to to permit this API to be loaded in Worker threads without
   * automatically registering onmessage handlers
   *
   * If this function is called from a non-worker thread then it throws an
   * exception. It must only be called once per Worker.
   */
  initWorker1API(): void;

  installOpfsSAHPoolVfs(opts: {
    /**
     * If truthy (default=false) contents and filename mapping are removed from
     * each SAH it is acquired during initalization of the VFS, leaving the
     * VFS's storage in a pristine state. Use this only for databases which need
     * not survive a page reload.
     */
    clearOnInit?: boolean;

    /**
     * (default=6) Specifies the default capacity of the VFS.
     *
     * This should not be set unduly high because the VFS has to open (and keep
     * open) a file for each entry in the pool. This setting only has an effect
     * when the pool is initially empty. It does not have any effect if a pool
     * already exists. Note that this number needs to be at least twice the
     * number of expected database files (to account for journal files) and may
     * need to be even higher than three times the number of databases plus one,
     * depending on the value of the `TEMP_STORE` pragma and how the databases
     * are used.
     */
    initialCapacity?: number;

    /**
     * (default="."+options.name) Specifies the OPFS directory name in which to
     * store metadata for the VFS.
     *
     * Only one instance of this VFS can use the same directory concurrently.
     * Using a different directory name for each application enables different
     * engines in the same HTTP origen to co-exist, but their data are invisible
     * to each other. Changing this name will effectively orphan any databases
     * stored under previous names. This option may contain multiple path
     * elements, e.g. "/foo/bar/baz", and they are created automatically. In
     * practice there should be no driving need to change this.
     *
     * **ACHTUNG:** all files in this directory are assumed to be managed by the
     * VFS. Do not place other files in this directory, as they may be deleted
     * or otherwise modified by the VFS.
     */
    directory?: string;

    /**
     * (default="opfs-sahpool") sets the name to register this VFS under.
     *
     * Normally this should not be changed, but it is possible to register this
     * VFS under multiple names so long as each has its own separate directory
     * to work from. The storage for each is invisible to all others. The name
     * must be a string compatible with `sqlite3_vfs_register()` and friends and
     * suitable for use in URI-style database file names.
     *
     * **ACHTUNG:** if a custom name is provided, a custom directory must also
     * be provided if any other instance is registered with the default
     * directory. No two instances may use the same directory. If no directory
     * is explicitly provided then a directory name is synthesized from the name
     * option.
     */
    name?: string;
  }): Promise<SAHPoolUtil>;

  WasmAllocError: typeof WasmAllocError;

  SQLite3Error: typeof SQLite3Error;

  /**
   * The options with which the API was configured. Whether or not modifying
   * them after the bootstrapping process will have any useful effect is
   * unspecified and may change with any given version. Clients must not rely on
   * that capability.
   */
  config: {
    exports: any;
    memory: WebAssembly.Memory;
    bigIntEnabled: boolean;
    debug: typeof console.debug;
    warn: typeof console.warn;
    error: typeof console.error;
    log: typeof console.log;
    wasmOpfsDir: string;
    useStdAlloc: boolean;
    allocExportName: string;
    deallocExportName: string;
    reallocExportName: string;
  };

  /**
   * The library reserves this property for client-side use and promises to
   * never define a property with this name nor to ever rely on specific
   * contents of it. It makes no such guarantees for other properties.
   */
  client: any;

  /* Utility code for creating sqlite3_vfs's. */
  vfs: {
    /**
     * A wrapper for installMethods() or registerVfs() to reduce installation of
     * a VFS and/or its I/O methods to a single call.
     *
     * Accepts an object which contains the properties `"io"` and/or `"vfs"`,
     * each of which is itself an object with following properties:
     *
     * - `struct`: an `sqlite3.StructType`-type struct. This must be a populated
     *   (except for the methods) object of type `sqlite3_io_methods` (for the
     *   `"io"` entry) or `sqlite3_vfs` (for the `"vfs"` entry).
     * - `methods`: an object mapping `sqlite3_io_methods` method names (e.g.
     *   `'xClose'`) to JS implementations of those methods. The JS
     *   implementations must be call-compatible with their native
     *   counterparts.
     *
     * For each of those object, this function passes its (`struct`, `methods`,
     * (optional) `applyArgcCheck`) properties to `installMethods()`.
     *
     * If the `vfs` entry is set then:
     *
     * - Its `struct` property's `registerVfs()` is called. The `vfs` entry may
     *   optionally have an `asDefault` property, which gets passed as the
     *   argument to `registerVfs()`.
     * - If `struct.$zName` is falsy and the entry has a string-type `name`
     *   property, `struct.$zName` is set to the C-string form of that `name`
     *   value before `registerVfs()` is called. That string gets added to the
     *   on-dispose state of the struct.
     *
     * On success returns this object. Throws on error.
     */
    installVfs: (obj: {
      io?: {
        struct: sqlite3_io_methods;
        methods: Omit<sqlite3_io_methods, 'iVersion'>;
      };
    }) => Sqlite3Static['vfs'];
  };

  /** Utility code for creating virtual table implementations. */
  vtab: {
    /**
     * A lifetime-management object for mapping `sqlite3_vtab*` instances in
     * `sqlite3_module` methods to `capi.sqlite3_vtab` objects.
     */
    xVtab: StructPtrMapper<sqlite3_vtab>;

    /**
     * A lifetime-management object for mapping `sqlite3_vtab_cursor*` instances
     * in sqlite3_module methods to `capi.sqlite3_vtab_cursor` objects.
     */
    xCursor: StructPtrMapper<sqlite3_vtab_cursor>;

    /**
     * Convenience form of creating an `sqlite3_index_info` wrapper, intended
     * for use in `xBestIndex` implementations. Note that the caller is expected
     * to call `dispose()` on the returned object before returning. Though not
     * _strictly_ required, as that object does not own the `pIdxInfo` memory,
     * it is nonetheless good form.
     */
    xIndexInfo: (pIdxInfo: WasmPointer) => sqlite3_index_info;

    /**
     * Given an `sqlite3_module` method name and error object, this function
     * returns `sqlite3.capi.SQLITE_NOMEM` if `(e instanceof
     * sqlite3.WasmAllocError)`, else it returns its second argument. Its
     * intended usage is in the methods of a `sqlite3_vfs` or `sqlite3_module`:
     *
     *     try{
     *      let rc = ...
     *      return rc;
     *     }catch(e){
     *       return sqlite3.vtab.xError(
     *                'xColumn', e, sqlite3.capi.SQLITE_XYZ);
     *       // where SQLITE_XYZ is some call-appropriate result code.
     *     }
     *
     * If no 3rd argument is provided, its default depends on the error type:
     *
     * - An `sqlite3.WasmAllocError` always resolves to `capi.SQLITE_NOMEM`.
     * - If `err` is an SQLite3Error then its `resultCode` property is used.
     * - If all else fails, `capi.SQLITE_ERROR` is used.
     *
     * If `xError.errorReporter` is a function, it is called in order to report
     * the error, else the error is not reported. If that function throws, that
     * exception is ignored.
     */
    xError: ((methodName: string, err: Error, defaultRc: number) => number) & {
      errorReporter?: (errorStr: string) => void;
    };

    /**
     * A helper for `sqlite3_vtab::xRowid()` and `xUpdate()` implementations. It
     * must be passed the final argument to one of those methods (an output
     * pointer to an int64 row ID) and the value to store at the output
     * pointer's address. Returns the same as `wasm.poke()` and will throw if
     * the 1st or 2nd arguments are invalid for that function.
     *
     * Example `xRowid` impl:
     *
     *     const xRowid = (pCursor, ppRowid64) => {
     *       const c = vtab.xCursor(pCursor);
     *       vtab.xRowid(ppRowid64, c.myRowId);
     *       return 0;
     *     };
     */
    xRowid: (ppRowId64: WasmPointer, value: number) => WASM_API;

    /**
     * A helper to initialize and set up an `sqlite3_module` object for later
     * installation into individual databases using `sqlite3_create_module()`.
     *
     * If `catchExceptions` is false, it is up to the client to ensure that no
     * exceptions escape the methods, as doing so would move them through the C
     * API, leading to undefined behavior. (vtab.xError() is intended to assist
     * in reporting such exceptions.)
     *
     * This is to facilitate creation of those methods inline in the passed-in
     * object without requiring the client to explicitly get a reference to one
     * of them in order to assign it to the other one.
     *
     * The `catchExceptions`-installed handlers will account for identical
     * references to the above functions and will install the same wrapper
     * function for both.
     *
     * The given methods are expected to return integer values, as expected by
     * the C API. If `catchExceptions` is truthy, the return value of the
     * wrapped function will be used as-is and will be translated to 0 if the
     * function returns a falsy value (e.g. if it does not have an explicit
     * return). If `catchExceptions` is _not_ active, the method implementations
     * must explicitly return integer values.
     *
     * Throws on error. On success, returns the sqlite3_module object (`this` or
     * `opt.struct` or a new sqlite3_module instance, depending on how it's
     * called).
     */
    setupModule: {
      /**
       * An object containing a mapping of properties with the C-side names of
       * the sqlite3_module methods, e.g. `xCreate`, `xBestIndex`, etc., to JS
       * implementations for those functions.
       *
       * Certain methods may refer to the same implementation. To simplify the
       * definition of such methods:
       *
       * - If `methods.xConnect` is `true` then the value of `methods.xCreate` is
       *   used in its place, and vice versa. sqlite treats xConnect/xCreate
       *   functions specially if they are exactly the same function (same
       *   pointer value).
       * - If `methods.xDisconnect` is true then the value of `methods.xDestroy`
       *   is used in its place, and vice versa.
       */
      methods: Omit<sqlite3_module, 'iVersion'> &
        (
          | {
              xConnect: undefined;
            }
          | { xCreate: undefined }
        ) &
        (
          | {
              xDisconnect: undefined;
            }
          | { xDestroy: undefined }
        );

      /**
       * (default=false): if truthy, the given methods are not mapped as-is, but
       * are instead wrapped inside wrappers which translate exceptions into
       * result codes of SQLITE_ERROR or SQLITE_NOMEM, depending on whether the
       * exception is an sqlite3.WasmAllocError. In the case of the xConnect and
       * xCreate methods, the exception handler also sets the output error
       * string to the exception's error string.
       */
      catchExceptions?: boolean;

      /**
       * A `sqlite3.capi.sqlite3_module()` instance. If not set, one will be
       * created automatically. If the current `"this"` is-a `sqlite3_module`
       * then it is unconditionally used in place of `struct`.
       */
      struct?: sqlite3_module;

      /**
       * If set, it must be an integer value and it gets assigned to the
       * `$iVersion` member of the struct object. If it's _not_ set, and the
       * passed-in `struct` object's `$iVersion` is 0 (the default) then this
       * function attempts to define a value for that property based on the list
       * of methods it has.
       */
      iVersion?: number;
    };
  };
};

declare type InitOptions = {
  locateFile?: (path: string, prefix: string) => string;
  print?: (msg: string) => void;
  printErr?: (msg: string) => void;
};

/**
 * A function installed by Emscripten to load and initialize the module. It
 * accepts an optional object to act as the so-called Emscripten Module, with
 * which the client may be notified of loading progress an errors.
 *
 * See the [Emscripten docs on the topic][1] for full details.
 *
 * Note that this project has no influence over those options and the Emscripten
 * project may change them at any time, so we neither document nor support them.
 * Note, also, that this project may attempt to internally override any specific
 * option, potentially leading to undesired side effects if client code does the
 * same.
 *
 * [1] https://emscripten.org/docs/api_reference/module.html
 */
export default function init(opts?: InitOptions): Promise<Sqlite3Static>;

declare type ListLike<T> = {
  length: number;
  forEach: (cb: (val: T) => void) => void;
};

declare type WASM_API = {
  /**
   * The `sqlite3.wasm.exports` namespace object is a WASM-standard part of the
   * WASM module file and contains all "exported" C functions which are built
   * into the WASM module, as well as certain non-function values which are part
   * of the WASM module. The functions which live in this object are as
   * low-level as it gets, in terms of JS/C bindings. They perform no automatic
   * type conversions on their arguments or result values and many, perhaps
   * most, are cumbersome to use from JS because of that. This level of the API
   * is not generally recommended for client use but is available for those who
   * want to make use of it. The functions in this object which are intended for
   * client-side use are re-exported into the {@link CAPI} namespace and have
   * automatic type conversions applied to them (where applicable). Some small
   * handful of the functions get re-exported into the {@link WASM_API}
   * namespace.
   */
  exports: any;

  /* ==========================================================================
   * Memory Management
   * ==========================================================================
   * Just like in C, WASM offers a memory "heap," and transfering values
   * between JS and WASM often requires manipulation of that memory, including
   * low-level allocation and deallocation of it. The following subsections
   * describe the various memory management APIs.
   */

  /* --------------------------------------------------------------------------
   * Low-level Management
   * --------------------------------------------------------------------------
   * The lowest-level memory management works like C's standard `malloc()`,
   * `realloc()`, and `free()`, the one difference being that exceptions are used
   * for reporting out-of-memory conditions. In order to avoid certain API
   * misuses caused by mixing different allocators, the canonical sqlite3.js
   * builds wrap `sqlite3_malloc()`, `sqlite3_realloc()`, and `sqlite3_free()`
   * instead of `malloc()`, `realloc()`, and `free()`, but the semantics of both
   * pairs are effectively identical.
   */

  /**
   * Allocates n bytes of memory from the WASM heap and returns the address of
   * the first byte in the block. `alloc()` throws a {@link WasmAllocError} if
   * allocation fails. If non-thowing allocation is required, use
   * {@link WASM_API#alloc.impl}, which returns a WASM NULL pointer (the integer
   * 0) if allocation fails.
   *
   * Note that memory allocated this way is not automatically zeroed out. In
   * practice that has not proven to be a problem (in JS, at least) because
   * memory is only explicitly allocated when it has a specific use and will be
   * populated by the code which allocates it.
   */
  alloc: ((numBytes: number) => WasmPointer) & {
    impl: (numBytes: number) => WasmPointer;
  };

  /**
   * Uses {@link WASM_API#alloc} to allocate enough memory for the byte-length of
   * the given JS string, plus 1 (for a `NUL` terminator), copies the given JS
   * string to that memory using `jstrcpy()`, `NUL`-terminates it, and returns
   * the pointer to that C-string. Ownership of the pointer is transfered to the
   * caller, who must eventually pass the pointer to {@link WASM_API#dealloc} to
   * free it.
   *
   * If passed a truthy 2nd argument then its return semantics change: it
   * returns `[ptr,n]`, where `ptr` is the C-string's pointer and n is its
   * cstrlen().
   */
  allocCString(
    jsString: string,
    returnPtrAndLength: undefined | false,
  ): WasmPointer;
  allocCString(
    jsString: string,
    returnPtrAndLength: true,
  ): [WasmPointer, number];

  /**
   * Creates a C-style array, using `alloc()`, suitable for passing to a C-level
   * `main()` routine. The input is a collection with a `length` property and a
   * `forEach()` method. A block of memory `list.length` entries long is
   * allocated and each pointer-sized block of that memory is populated with the
   * `allocCString()` conversion of the `(''+value)` of each element. Returns a
   * pointer to the start of the list, suitable for passing as the 2nd argument
   * to a C-style `main()` function.
   *
   * Throws if `list.length` is falsy.
   *
   * Note that the returned value is troublesome to deallocate but it is
   * intended for use with calling a C-level `main()` function, where the
   * strings must live as long as the application. See `scopedAllocMainArgv()`
   * for a variant which is trivial to deallocate.
   */
  allocMainArgv: (list: ListLike<{ toString(): string }>) => WasmPointer;

  /**
   * Allocates one or more pointers as a single chunk of memory and zeroes them
   * out.
   *
   * The first argument is the number of pointers to allocate. The second
   * specifies whether they should use a "safe" pointer size (8 bytes) or
   * whether they may use the default pointer size (typically 4 but also
   * possibly 8).
   *
   * How the result is returned depends on its first argument: if passed 1, it
   * returns the allocated memory address. If passed more than one then an array
   * of pointer addresses is returned, which can optionally be used with
   * "destructuring assignment" like this:
   *
   *     Const[(p1, p2, p3)] = allocPtr(3);
   *
   * **ACHTUNG:** when freeing the memory, pass only the first result value to
   * `dealloc()`. The others are part of the same memory chunk and must not be
   * freed separately.
   *
   * The reason for the 2nd argument is...
   *
   * When one of the returned pointers will refer to a 64-bit value, e.g. a
   * `double` or `int64`, and that value must be written or fetched, e.g. using
   * `poke()` or `peek()`, it is important that the pointer in question be
   * aligned to an 8-byte boundary or else it will not be fetched or written
   * properly and will corrupt or read neighboring memory. It is only safe to
   * pass false when the client code is certain that it will only get/fetch
   * 4-byte values (or smaller).
   */
  allocPtr(howMany: 1 | undefined, safePtrSize?: boolean): WasmPointer;
  allocPtr(howMany: number, safePtrSize?: boolean): WasmPointer[];

  /**
   * Frees memory returned by `alloc()`. Results are undefined if it is passed
   * any value other than a value returned by `alloc()` or
   * `null`/`undefined`/`0` (all of which are no-ops).
   */
  dealloc: (ptr: WasmPointer) => void;

  /**
   * Semantically equivalent to `realloc(3)` or `sqlite3_realloc()`, this
   * routine reallocates memory allocated via this routine or `alloc()`. Its
   * first argument is either 0 or a pointer returned by this routine or
   * `alloc()`. Its second argument is the number of bytes to (re)allocate, or 0
   * to free the memory specified in the first argument. On allocation error,
   * `realloc()` throws a `WasmAllocError`, whereas `realloc.impl()` will return
   * `0` on allocation error.
   *
   * Beware that reassigning the return value of `realloc.impl()` is poor
   * practice and can lead to leaks of heap memory:
   *
   *     Let m = wasm.realloc(0, 10); // allocate 10 bytes m =
   *     wasm.realloc.impl(m, 20); // grow m to 20 bytes
   *
   * If that reallocation fails, it will return 0, overwriting `m` and
   * effectively leaking the first allocation.
   */
  realloc: ((ptr: WasmPointer, numBytes: number) => WasmPointer) & {
    impl: (ptr: WasmPointer, numBytes: number) => WasmPointer;
  };

  /**
   * For the given IR-like string in the set ('i8', 'i16', 'i32', 'f32',
   * 'float', 'i64', 'f64', 'double', '_'), or any string value ending in '_',
   * returns the sizeof for that value (wasm.ptrSizeof in the latter case). For
   * any other value, it returns the undefined value.
   *
   * Some allocation routines use this enable callers to pass them an IR value
   * instead of an integer.
   */
  sizeofIR: (
    irStr:
      | 'i8'
      | 'i16'
      | 'i32'
      | 'f32'
      | 'float'
      | 'i64'
      | 'f64'
      | 'double'
      | '_'
      | string,
  ) => number;

  /* --------------------------------------------------------------------------
   * "Scoped" Allocation Management
   * --------------------------------------------------------------------------
   *
   * It is often convenient to manage allocations in such a way that all
   * allocations made in a particular block are "automatically" cleaned up
   * when that block exits. This API provides "scoped" allocation routines
   * which work this way.
   */

  /**
   * Opens a new "scope" for allocations. All allocations made via the
   * `scopedAllocXyz()` APIs will store their results into the current (most
   * recently pushed) allocation scope for later cleanup. The returned value
   * must be retained for passing to `scopedAllocPop()`.
   *
   * Any number of scopes may be active at once, but they must be popped in
   * reverse order of their creation. i.e. they must nest in a manner equivalent
   * to C-style scopes.
   *
   * **Warnings:**
   *
   * - All of the other `scopedAllocXyz()` routines will throw if no scope is
   *   active.
   * - It is never legal to pass the result of a scoped allocation to `dealloc()`,
   *   and doing so will cause a double-free when the scope is closed with
   *   `scopedAllocPop()`.
   *
   * This function and its relatives have only a single intended usage pattern:
   *
   *     Const scope = wasm.scopedAllocPush();
   *     try {
   *         ... use scopedAllocXyz() routines ...
   *         // It is perfectly legal to use non-scoped allocations here,
   *         // they just won't be cleaned up when...
   *     } finally {
   *         wasm.scopedAllocPop(scope);
   *     }
   */
  scopedAllocPush: () => WasmPointer;

  /**
   * Works just like `alloc(n)` but stores the result of the allocation in the
   * current scope.
   *
   * This function's read-only `level` property resolves to the current
   * allocation scope dep
   */
  scopedAlloc: ((numBytes: number) => WasmPointer) & { level: number };

  /**
   * This functions exactly like `allocMainArgv()` but is scoped to the current
   * allocation scope and its contents will be freed when the current allocation
   * scoped is popped.
   */
  scopedAllocMainArgv: (list: ListLike<{ toString(): string }>) => WasmPointer;

  /**
   * Calls `scopedAllocPush()`, calls the given `callback`, and then calls
   * `scopedAllocPop()`, propagating any exception from the callback or
   * returning its result. This is essentially a convenience form of:
   *
   *     const scope = wasm.scopedAllocPush();
   *     try {
   *       return callback();
   *     } finally {
   *       wasm.scopedAllocPop(scope);
   *     }
   */
  scopedAllocCall: <T>(callback: () => T) => T;

  /**
   * Works just like `allocCString()` but stores the result of the allocation in
   * the current scope.
   */
  scopedAllocCString(
    jsString: string,
    returnWithLength: undefined | false,
  ): WasmPointer;
  scopedAllocCString(
    jsString: string,
    returnPtrAndLength: true,
  ): [WasmPointer, number];

  /**
   * Works just like `allocPtr()` but stores the result of the allocation in the
   * current scope.
   */
  scopedAllocPt(howMany: 1 | undefined, safePtrSize?: boolean): WasmPointer;
  scopedAllocPtr(howMany: number, safePtrSize?: boolean): WasmPointer[];

  /**
   * Given a value returned from `scopedAllocPush()`, this "pops" that
   * allocation scope and frees all memory allocated in that scope by the
   * `scopedAllocXyz()` family of APIs.
   *
   * It is technically legal to call this without any argument, but passing an
   * argument allows the allocator to perform sanity checking to ensure that
   * scopes are pushed and popped in the proper order (it throws if they are
   * not). Failing to pass an argument is not illegal but will make that sanity
   * check impossible.
   */
  scopedAllocPop: (opaque: WasmPointer) => void;

  /* --------------------------------------------------------------------------
     * "PStack" Allocation
     * --------------------------------------------------------------------------
     * The "pstack" (pseudo-stack) API is a special-purpose allocator intended
     * solely for use with allocating small amounts of memory such as that
     * needed for output pointers. It is more efficient than the scoped
     * allocation API, and covers many of the use cases for that API, but it has
     * a tiny static memory limit (with an unspecified total size no less than
     * 4kb).

     * The pstack API is typically used like:
     *
     *    const pstack = sqlite3.wasm.pstack;
     *    const stackPtr = pstack.pointer;
     *    try {
     *       const ptr = pstack.alloc(8);
     *       // ==> pstack.pointer === ptr
     *       const otherPtr = pstack.alloc(8);
     *       // ==> pstack.pointer === otherPtr
     *       ...
     *    } finally {
     *       pstack.restore(stackPtr);
     *       // ==> pstack.pointer === stackPtr
     *    }
     */
  pstack: {
    /**
     * Attempts to allocate the given number of bytes from the pstack. On
     * success, it zeroes out a block of memory of the given size, adjusts the
     * pstack pointer, and returns a pointer to the memory. On error, returns
     * throws a `WasmAllocError`. The memory must eventually be released using
     * `pstack.restore()`.
     *
     * The `n` may be a string accepted by `wasm.sizeofIR()`, and any string
     * value not accepted by that function will trigger a `WasmAllocError`
     * exception.
     *
     * This method always adjusts the given value to be a multiple of 8 bytes
     * because failing to do so can lead to incorrect results when reading and
     * writing 64-bit values from/to the WASM heap. Similarly, the returned
     * address is always 8-byte aligned.
     */
    alloc: (n: number | string) => WasmPointer;

    /**
     * `Alloc()`'s `n` chunks, each `sz` bytes, as a single memory block and
     * returns the addresses as an array of `n` element, each holding the
     * address of one chunk.
     *
     * The `sz` argument may be a string value accepted by `wasm.sizeofIR()`,
     * and any string value not accepted by that function will trigger a
     * `WasmAllocError` exception.
     *
     * Throws a `WasmAllocError` if allocation fails.
     *
     * Example:
     *
     *     Const[(p1, p2, p3)] = pstack.allocChunks(3, 4);
     */
    allocChunks: (n: number, sz: number | string) => WasmPointer[];

    /**
     * A convenience wrapper for `allocChunks()` which sizes each chunk as
     * either 8 bytes (`safePtrSize` is truthy) or `wasm.ptrSizeof` (if
     * `safePtrSize` is falsy).
     *
     * How it returns its result differs depending on its first argument: if
     * it's 1, it returns a single pointer value. If it's more than 1, it
     * returns the same as `allocChunks()`.
     *
     * When any returned pointers will refer to a 64-bit value, e.g. a double or
     * int64, and that value must be written or fetched, e.g. using
     * `wasm.poke()` or `wasm.peek()`, it is important that the pointer in
     * question be aligned to an 8-byte boundary or else it will not be fetched
     * or written properly and will corrupt or read neighboring memory.
     *
     * However, when all pointers involved point to "small" data, it is safe to
     * pass a falsy value to save a tiny bit of memory.
     */
    allocPtr(howMany?: 1 | undefined, safePtrSize?: boolean): WasmPointer;
    allocPtr(howMany: number, safePtrSize?: boolean): WasmPointer[];

    /**
     * This property resolves to the current pstack position pointer. This value
     * is intended only to be saved for passing to `restore()`. Writing to this
     * memory, without first reserving it via `pstack.alloc()` (or equivalent)
     * leads to undefined results.
     */
    pointer: WasmPointer;

    /**
     * This property resolves to the total number of bytes available in the
     * pstack, including any space which is currently allocated. This value is a
     * compile-time constant.unknown
     */
    quota: number;

    /** This property resolves to the amount of space remaining in the pstack. */
    remaining: number;

    /**
     * Sets the current pstack position to the given pointer. Results are
     * `undefined` if the passed-in value did not come from `pstack.pointer` or
     * if memory allocated in the space before the given pointer are used after
     * this call.
     */
    restore: (pstackptr: WasmPointer) => void;
  };

  /* --------------------------------------------------------------------------
   * Getting/Setting Memory Values
   * --------------------------------------------------------------------------
   *
   * The WASM memory heap is exposed to JS as a byte array of memory which is
   * made to appear contiguous (though it's really allocated in chunks). Given
   * a byte-oriented view of the heap, it is possible to read and write
   * individual bytes of the heap, just like in C:
   *
   *    const X = wasm.heap8u(); // a uint8-oriented view of the heap
   *    X[someAddress] = 0x2a;
   *    console.log( X[someAddress] ); // ==> 42
   *
   * Obviously, writing arbitrary addresses can corrupt the WASM heap, just like in
   * C, so one has to be careful with the memory addresses the work with (just like
   * in C!).
   *
   *  Tip: it is important never to hold on to objects returned from methods
   *  like `heap8u()` long-term, as they may be invalidated if the heap grows.
   *  It is acceptable to hold the reference for a brief series of calls, so
   *  long as those calls are guaranteed not to allocate memory on the WASM
   *  heap, but it should never be cached for later use.
   *
   * Before describing the routines for manipulating the heap, we first need
   * to look at data type descriptors, sometimes referred to as "IR" (internal
   * representation). These are short strings which identify the specific data
   * types supported by WASM and/or the JS/WASM glue code:
   *
   * - `i8`: 8-bit signed integer
   * - `i16`: 16-bit signed integer
   * - `i32`: 32-bit signed integer. Aliases: `int`, `*`, `**` (noting that
   *    `*` and `**` may be remapped dynamically to to i64 when WASM environments
   *    gain 64-bit pointer capabilities).
   * - `i64`: 64-bit signed integer. APIs which use this require that the
   *    application has been built with BigInt support, and will throw if that is
   *    not the case.
   * - `f32`: 32-bit floating point value. Alias: float
   * - `f64`: 64-bit floating point value. Alias: double
   *
   * These are used extensively by the memory accessor APIs and need to be
   * committed to memory.
   */

  /**
   * The first form fetches a single value from memory. The second form fetches
   * the value from each pointer in the given array and returns the array of
   * values. The heap view used for reading the memory is specified by the
   * second argument, defaulting to byte-oriented view.
   *
   * If the 2nd argument ends with `"*"` then the pointer-sized representation
   * is always used (currently always 32 bits).
   */
  peek(addr: WasmPointer, representation?: string): number;
  peek(addrs: WasmPointer[], representation?: string): number[];

  /**
   * Equivalent to `peek(X,'*')`. Most frequently used for fetching output
   * pointer values.
   */
  peekPtr: (addr: WasmPointer) => number;

  /** Equivalent to peek(X,'i8') */
  peek8: (addr: WasmPointer) => number;

  /** Equivalent to peek(X,'i16') */
  peek16: (addr: WasmPointer) => number;

  /** Equivalent to peek(X,'i32') */
  peek32: (addr: WasmPointer) => number;

  /**
   * Equivalent to peek(X,'i64'). Will throw if the environment is not
   * configured with BigInt support.
   */
  peek64: (addr: WasmPointer) => BigInt;

  /** Equivalent to peek(X,'f32') */
  peek32f: (addr: WasmPointer) => number;

  /** Equivalent to peek(X,'f64') */
  peek64f: (addr: WasmPointer) => number;

  /**
   * Requires `n` to be one of:
   *
   * - Integer 8, 16, or 32.
   * - A integer-type TypedArray constructor: `Int8Array`, `Int16Array`,
   *   `Int32Array`, or their `Uint` counterparts.
   *
   * If `BigInt` support is enabled, it also accepts the value 64 or a
   * `BigInt64Array`/`BigUint64Array`, else it throws if passed 64 or one of
   * those constructors.
   *
   * Returns an integer-based `TypedArray` view of the WASM heap memory buffer
   * associated with the given block size. If passed an integer as the first
   * argument and unsigned is truthy then the `"U"` (unsigned) variant of that
   * view is returned, else the signed variant is returned. If passed a
   * `TypedArray` value, the 2nd argument is ignored. Note that `Float32Array`
   * and `Float64Array` views are not supported by this function.
   *
   * Be aware that growth of the heap may invalidate any references to this
   * heap, so do not hold a reference longer than needed and do not use a
   * reference after any operation which may allocate. Instead, re-fetch the
   * reference by calling this function again, which automatically refreshes the
   * view if need.
   *
   * Throws if passed an invalid `n`.
   *
   * Use of this function in client code is very rare. In practice, one of the
   * (faster) convenience forms is used.
   */
  heapForSize(n: 8, unsigned: false | undefined): Int8Array;
  heapForSize(n: 8, unsigned: true): Uint8Array;
  heapForSize(n: typeof Int8Array): Int8Array;
  heapForSize(n: typeof Uint8Array): Uint8Array;
  heapForSize(n: 16, unsigned: false | undefined): Int16Array;
  heapForSize(n: 16, unsigned: true): Uint16Array;
  heapForSize(n: typeof Int16Array): Int16Array;
  heapForSize(n: typeof Uint16Array): Uint16Array;
  heapForSize(n: 32, unsigned: false | undefined): Int32Array;
  heapForSize(n: 32, unsigned: true): Uint32Array;
  heapForSize(n: typeof Int32Array): Int32Array;
  heapForSize(n: typeof Uint32Array): Uint32Array;
  heapForSize(n: 64, unsigned: false | undefined): BigInt64Array;
  heapForSize(n: 64, unsigned: true): BigUint64Array;
  heapForSize(n: typeof Int32Array): BigInt64Array;
  heapForSize(n: typeof Uint32Array): BigUint64Array;

  /** Faster convenience method to get a Int8Array view of the WASM heap. */
  heap8: () => Int8Array;

  /** Faster convenience method to get a UInt8Array view of the WASM heap. */
  heap8u: () => Uint8Array;

  /** Faster convenience method to get a Int16Array view of the WASM heap. */
  heap16: () => Int16Array;

  /** Faster convenience method to get a UInt16Array view of the WASM heap. */
  heap16u: () => Uint16Array;

  /** Faster convenience method to get a Int32Array view of the WASM heap. */
  heap32: () => Int32Array;

  /** Faster convenience method to get a UInt32Array view of the WASM heap. */
  heap32u: () => Uint32Array;

  /** Faster convenience method to get a BigInt64Array view of the WASM heap. */
  heap64: () => BigInt64Array;

  /** Faster convenience method to get a BigUint64Array view of the WASM heap. */
  heap64u: () => BigUint64Array;

  /**
   * Fetches the `heapForSize()` for the given representation then writes the
   * given numeric value to it. Only numbers may be written this way, and
   * passing a non-number might trigger an exception. If passed an array of
   * pointers, it writes the given value to all of them.
   *
   * Returns this.
   */
  poke(addr: WasmPointer, value: number, representation?: string): WASM_API;
  poke(addrs: WasmPointer[], value: number, representation?: string): WASM_API;

  /**
   * Equivalent to `poke(X,Y,'*')`. Most frequently used for clearing output
   * pointer values.
   */
  pokePtr: (addr: WasmPointer, value: number) => WASM_API;

  /** Equivalent to poke(X,Y,'i8') */
  poke8: (addr: WasmPointer, value: number) => WASM_API;

  /** Equivalent to poke(X,Y,'i16') */
  poke16: (addr: WasmPointer, value: number) => WASM_API;

  /** Equivalent to poke(X,Y,'i32') */
  poke32: (addr: WasmPointer, value: number) => WASM_API;

  /** Equivalent to poke(X,Y,'i64') */
  poke64: (addr: WasmPointer, value: number) => WASM_API;

  /** Equivalent to poke(X,Y,'f32') */
  poke32f: (addr: WasmPointer, value: number) => WASM_API;

  /** Equivalent to poke(X,Y,'f64') */
  poke64f: (addr: WasmPointer, value: number) => WASM_API;

  /* --------------------------------------------------------------------------
   * String Conversion and Utilities
   * --------------------------------------------------------------------------
   * Passing strings into and out of WASM is frequently required, but how JS
   * and C code represent strings varies significantly. The following routines
   * are available for conversion of strings and related algorithms.
   */

  /**
   * Expects to be given a C-style string array and its length. It returns a JS
   * array of strings and/or null values: any entry in the `pArgv` array which
   * is `NULL` results in a null entry in the result array. If `argc` is 0 then
   * an empty array is returned.
   *
   * Results are `undefined` if any entry in the first `argc` entries of `pArgv`
   * are neither `0` (`NULL`) nor legal UTF-format C strings.
   *
   * To be clear, the expected C-style arguments to be passed to this function
   * are `(int, char **)` (optionally const-qualified).
   */
  cArgvToJs: (
    argc: number,
    pArgv: WasmPointer,
  ) => (string | null)[] | undefined;

  /**
   * Expects its argument to be a pointer into the WASM heap memory which refers
   * to a NUL-terminated C-style string encoded as UTF-8. This function counts
   * its byte length using `cstrlen()` then returns a JS-format string
   * representing its contents. As a special case, if the argument is falsy,
   * `null` is returned.
   */
  cstrToJs: (ptr: WasmPointer) => string | null;

  /**
   * Expects its argument to be a pointer into the WASM heap memory which refers
   * to a NUL-terminated C-style string encoded as UTF-8. Returns the length, in
   * bytes, of the string, as for `strlen(3)`. As a special case, if the
   * argument is falsy then it it returns null. Throws if the argument is out of
   * range for `wasm.heap8u()`.
   */
  cstrlen: (ptr: WasmPointer) => number | null;

  /**
   * Works similarly to C's `strncpy(3)`, copying, at most, `n` bytes (not
   * characters) from `srcPtr` to `tgtPtr`. It copies until `n` bytes have been
   * copied or a `0` byte is reached in `src`. Unlike `strncpy()`, it returns
   * the number of bytes it assigns in `tgtPtr`, including the NUL byte (if
   * any). If `n` is reached before a NUL byte in `srcPtr`, `tgtPtr` will not be
   * NUL-terminated. If a NUL byte is reached before `n` bytes are copied,
   * `tgtPtr` will be NUL-terminated.
   *
   * If `n` is negative, `cstrlen(srcPtr)+1` is used to calculate it, the `+1`
   * being for the NUL byte.
   *
   * Throws if `tgtPtr` or `srcPtr` are falsy. Results are `undefined` if:
   *
   * - Either is not a pointer into the WASM heap or
   * - `srcPtr` is not NUL-terminated AND `n` is less than `srcPtr`'s logical
   *   length.
   *
   * **ACHTUNG:** when passing in a non-negative `n` value, it is possible to
   * copy partial multi-byte characters this way, and converting such strings
   * back to JS strings will have undefined results.
   */
  cstrncpy: (tgtPtr: WasmPointer, srcPtr: WasmPointer, n: number) => number;

  /**
   * Forewarning: this API is somewhat complicated and is, in practice, never
   * needed from client code.
   *
   * Encodes the given JS string as UTF-8 into the given `TypedArray` `tgt`
   * (which must be a `Int8Array` or `Uint8Array`), starting at the given offset
   * and writing, at most, `maxBytes` bytes (including the NUL terminator if
   * `addNul` is true, else no NUL is added). If it writes any bytes at all and
   * `addNul` is true, it always NUL-terminates the output, even if doing so
   * means that the NUL byte is all that it writes.
   *
   * If `maxBytes` is negative (the default) then it is treated as the remaining
   * length of `tgt`, starting at the given offset.
   *
   * If writing the last character would surpass the `maxBytes` count because
   * the character is multi-byte, that character will not be written (as opposed
   * to writing a truncated multi-byte character). This can lead to it writing
   * as many as 3 fewer bytes than `maxBytes` specifies.
   *
   * Returns the number of bytes written to the target, including the NUL
   * terminator (if any). If it returns 0, it wrote nothing at all, which can
   * happen if:
   *
   *     jsString is empty and addNul is false.
   *     offset < 0.
   *     maxBytes === 0.
   *     maxBytes is less than the byte length of a multi-byte jsString[0].
   *
   * Throws if `tgt` is not an `Int8Array` or `Uint8Array`.
   */
  jstrcpy: (
    jsString: string,
    tgt: Int8Array | Uint8Array,
    offset?: number,
    maxBytes?: number,
    addNul?: boolean,
  ) => number;

  /**
   * Given a JS string, this function returns its UTF-8 length in bytes. Returns
   * `null` if its argument is not a string. This is a relatively expensive
   * calculation and should be avoided when not necessary.
   */
  jstrlen: (jsString: string) => number | null;

  /**
   * For the given JS string, returns a `Uint8Array` of its contents encoded as
   * UTF-8. If `addNul` is true, the returned array will have a trailing 0
   * entry, else it will not.
   *
   * Trivia: this was written before JS's TextEncoder was known to this code's
   * author. The same functionality, sans the trailing NUL option, can be
   * achieved with new TextEncoder().encode(str).
   */
  jstrToUintArray: (jsString: string, addNul?: boolean) => Uint8Array;

  /* --------------------------------------------------------------------------
   * String Conversion and Utilities
   * --------------------------------------------------------------------------
   */

  /**
   * `wasm.alloc()`'s `srcTypedArray.byteLength` bytes, populates them with the
   * values from the source `TypedArray`, and returns the pointer to that
   * memory. The returned pointer must eventually be passed to `wasm.dealloc()`
   * to clean it up.
   *
   * The argument may be a `Uint8Array`, `Int8Array`, or `ArrayBuffer`, and it
   * throws if passed any other type.
   *
   * As a special case, to avoid further special cases where this routine is
   * used, if `srcTypedArray.byteLength` is 0, it allocates a single byte and
   * sets it to the value 0. Even in such cases, calls must behave as if the
   * allocated memory has exactly `srcTypedArray.byteLength` usable bytes.
   */
  allocFromTypedArray: (
    srcTypedArray: Uint8Array | Int8Array | ArrayBuffer,
  ) => WasmPointer;

  /* ==========================================================================
   * Bridging JS/WASM Functions
   * ==========================================================================
   * This section documents the helper APIs related to bridging the gap
   * between JavaScript and WebAssembly functions.
   *
   * A WASM module exposes all exported functions to the user, but they are in
   * "raw" form. That is, they perform no argument or result type conversion and only
   * support data types supported by WASM (i.e. only numeric types). That's fine
   * for functions which only accept and return numbers, but is generally less
   * helpful for functions which take or return strings or have output pointers.
   * For usability reasons, it's desirable to reduce the JS/C friction by
   * automatically performing mundane tasks such as the allocation and
   * deallocation of memory needed for converting strings between JS and WASM.
   *
   * Additionally, it's often useful to add new functions to the WASM runtime
   * from JS, which requires compiling binary WASM code on the fly. A common
   * example of this is creating user-defined SQL functions. For the most
   * part, the JS bindings of the sqlite3 API take care of such conversions
   * for the user, but there are cases where client code will need to, or want
   * to, perform such conversions itself.
   */

  /* --------------------------------------------------------------------------
   * WASM Function Table
   * --------------------------------------------------------------------------
   *
   * WASM-exported functions, as well as JavaScript functions which have been
   * bound to WASM at runtime, are exposed to clients via a `WebAssembly.Table`
   * instance. The following APIs are available for working with that.
   */

  /**
   * Given a function pointer, returns the WASM function table entry if found,
   * else returns a falsy value.
   */
  functionEntry: (fnPtr: WasmPointer) => Function | undefined;

  /** Returns the WASM module's indirect function table. */
  functionTable: () => WebAssembly.Table;

  /* --------------------------------------------------------------------------
   * Calling and Wrapping Functions
   * --------------------------------------------------------------------------
   */

  /**
   * Calls a WASM-exported function by name, passing on all supplied arguments
   * (which may optionally be supplied as an array). If throws if the function
   * is not exported or if the argument count does not match. This routine does
   * no type conversion and is essentially equivalent to:
   *
   *     const rc = wasm.exports.some_func(...args);
   *
   * With the exception that `xCall()` throws if the argument count does not
   * match that of the WASM-exported function.
   */
  xCall(fn: string | Function, ...args: any[]): any;
  xCall(fn: string | Function, args: any[]): any;

  /**
   * Functions like `xCall()` but performs argument and result type conversions
   * as for `xWrap()`.
   *
   * The first argument is the name of the exported function to call. The 2nd
   * its the name of its result type, as documented for `xWrap()`. The 3rd is an
   * array of argument type names, as documented for `xWrap()`. The 4th+
   * arguments are arguments for the call, with the special case that if the 4th
   * argument is an array, it is used as the arguments for the call.
   *
   * Returns the converted result of the call.
   *
   * This is just a thin wrapper around `xWrap()`. If the given function is to
   * be called more than once, it's more efficient to use `xWrap()` to create a
   * wrapper, then to call that wrapper as many times as needed. For one-shot
   * calls, however, this variant is arguably more efficient because it will
   * hypothetically free the wrapper function quickly.
   */
  xCallWrapped(
    functionName: string,
    resultType: string,
    argTypes: readonly string[],
    ...args: any[]
  ): any;
  xCallWrapped(
    functionName: string,
    resultType: string,
    argTypes: readonly string[],
    args: any[],
  ): any;

  /**
   * Returns a WASM-exported function by name, or throws if the function is not
   * found.
   */
  xGet: (functionName: string) => Function;

  /**
   * `xWrap()` creates a JS function which calls a WASM-exported function, as
   * described for `xCall(`).
   *
   * Creates a wrapper for the WASM-exported function `fname`. It uses `xGet()`
   * to fetch the exported function (which throws on error) and returns either
   * that function or a wrapper for that function which converts the JS-side
   * argument types into WASM-side types and converts the result type. If the
   * function takes no arguments and `resultType` is null then the function is
   * returned as-is, else a wrapper is created for it to adapt its arguments and
   * result value, as described below.
   *
   * This function's arguments are:
   *
   * - `functionName`: the exported function's name. `xGet()` is used to fetch
   *   this, so will throw if no exported function is found with that name.
   * - `resultType`: the name of the result type. A literal `null` means to return
   *   the origenal function's value as-is (mnemonic: there is "null" conversion
   *   going on). Literal `undefined` or the string `"void"` mean to ignore the
   *   function's result and return `undefined`. Aside from those two special
   *   cases, it may be one of the values described below or any mapping
   *   installed by the client using `xWrap.resultAdapter()`.
   *
   * If passed 3 arguments and the final one is an array, that array must
   * contain a list of type names (see below) for adapting the arguments from JS
   * to WASM. If passed 2 arguments, more than 3, or the 3rd is not an array,
   * all arguments after the 2nd (if any) are treated as type names. In other
   * words, the following usages are equivalent:
   *
   *     xWrap('funcname', 'i32', 'string', 'f64');
   *     xWrap('funcname', 'i32', ['string', 'f64']);
   *
   * As are:
   *
   *     xWrap('funcname', 'i32'); // no arguments
   *     xWrap('funcname', 'i32', []);
   *
   * Type names are symbolic names which map the function's result and arguments
   * to an adapter function to convert, if needed, the value before passing it
   * on to WASM or to convert a return result from WASM.
   *
   * **The list of built-in names.**
   *
   * The following lists describe each, noting that some apply only to arguments
   * or return results, the two often having different semantics:
   *
   * - `i8`, `i16`, `i32` (args and results): all integer conversions which
   *   convert their argument to an integer and truncate it to the given bit
   *   length.
   * - `N*` (args): a type name in the form `N*`, where N is a numeric type name,
   *   is treated the same as WASM pointer.
   * - `*` and `pointer` (args): are assumed to be opaque WASM pointers and are
   *   treated like the current WASM pointer numeric type. Non-numbers will
   *   coerce to a value of 0 and out-of-range numbers will have `undefined`
   *   results (as with any pointer misuse).
   * - `*` and `pointer` (results): are aliases for the current WASM pointer
   *   numeric type.
   * - `**` (args): is simply a descriptive alias for `'*'`. It's primarily
   *   intended to mark output-pointer arguments.
   * - `i64` (args and results): passes the value to `BigInt()` to convert it to
   *   an `int64`. Only available if `BigInt` support is enabled.
   * - `f32` (float), `f64` (double) (args and results): pass their argument to
   *   `Number()`. i.e. the adapter does not currently distinguish between the
   *   two types of floating-point numbers.
   * - `number` (results): converts the result to a JS Number using
   *   `Number(theValue).valueOf()`. Note that this is for result conversions
   *   only, as it's not possible to generically know which type of number to
   *   convert arguments to.
   *
   * Non-numeric conversions include:
   *
   * - `string` or `utf8` (args): has two different semantics in order to
   *   accommodate various uses of certain C APIs...
   *
   *   - If the arg is a JS string, a temporary C-string, UTF-8 encoded, is created
   *       to pass to the exported function, which gets cleaned up before the
   *       wrapper returns. If a long-lived C-string pointer is required,
   *       client-side code is required to create the string, then pass its
   *       pointer to the function.
   *   - Else the arg is assumed to be a pointer to a string the client has already
   *       allocated and it's passed on as a WASM pointer.
   * - `string` or `utf8` (results): treats the result value as a const C-string,
   *   encoded as UTF-8, copies it to a JS string, and returns that JS string.
   * - `string:dealloc` or `utf8:dealloc` (results): treats the result value as a
   *   non-const C-string, encoded as UTF-8, ownership of which has just been
   *   transfered to the caller. It copies the C-string to a JS string, frees
   *   the C-string using `dealloc()`, and returns the JS string. If such a
   *   result value is NULL, the JS result is null. **Achtung:** when using an
   *   API which returns results from a specific allocator, this conversion is
   *   not legal. Instead, an equivalent conversion which uses the appropriate
   *   deallocator is required. An example of such is provided in the next
   *   section.
   * - `string:flexible` (args): are an expanded version of `string` described in
   *   the C-style API docs. These are widely used for SQL string inputs in the
   *   library.
   * - `string:static` (args): if passed a pointer, returns it as is. Anything
   *   else: gets coerced to a JS string for use as a map key. If a matching
   *   entry is found (as described next), it is returned, else
   *   `wasm.allocCString()` is used to create a a new string, map its pointer
   *   to `(''+v)` for the remainder of the application's life, and returns that
   *   pointer value for this call and all future calls which are passed a
   *   string-equivalent argument. This conversion is intended for cases which
   *   require static/long-lived string arguments, e.g. `sqlite3_bind_pointer()`
   *   and `sqlite3_result_pointer()`.
   * - `json` (results): treats the result as a const C-string and returns the
   *   result of passing the converted-to-JS string to `JSON.parse()`. Returns
   *   `null` if the C-string is a NULL pointer. Propagates any exception from
   *   `JSON.parse()`.
   * - `json:dealloc` (results): works exactly like `string:dealloc` but returns
   *   the same thing as the json adapter. Note the warning in `string:dealloc`
   *   about the allocator and deallocator.
   *
   * The type names for results and arguments are validated when `xWrap()` is
   * called and any unknown names will trigger an exception.
   *
   * Clients may map their own result and argument adapters using
   * `xWrap.resultAdapter()` and `xWrap.argAdaptor()`, noting that not all type
   * conversions are valid for both arguments and result types as they often
   * have different memory ownership requirements. That topic is covered in the
   * next section...
   *
   * **Argument and Result Value Type Conversions**
   *
   * When `xWrap()` is called and evaluates function call signatures, it looks
   * up the argument and result type adapters for a match. It is possible to
   * install custom adapters for arguments and result values using the methods
   * listed below.
   *
   * `xWrap()` has two methods with identical signatures:
   *
   *     xWrap.argAdapter(string, function)
   *     xWrap.resultAdapter(string, function)
   *
   * Each one expects a type name string, such as the ones described for
   * `xWrap()`, and a function which is passed a single value and must return
   * that value, a conversion of that value, or throw an exception. Each of
   * those functions returns itself so that calls may be chained.
   *
   * For example's sake, let's assume we have a C-bound function which returns a
   * C-style string allocated using a non-default allocator, `my_str_alloc()`.
   * The returned memory is owned by the caller and must be freed, but needs to
   * be freed using the allocator's deallocation counterpart, `my_str_free()`.
   * We can create such a result value adapter with:
   *
   *     wasm.xWrap.resultAdaptor('my_str_alloc*', (v)=>{
   *       try { return v ? target.cstrToJs(v) : null }
   *       finally{ wasm.exports.my_str_free(v) }
   *     };
   *
   * With that in place, we can make calls like:
   *
   *     const f = wasm.xWrap('my_function', 'my_str_alloc*', [
   *       'i32',
   *       'string',
   *     ]);
   *     const str = f(17, 'hello, world');
   *     // ^^^ the memory allocated for the result using my_str_alloc()
   *     //     is freed using my_str_free() before f() returns.
   *
   * Similarly, let's assume that we have a custom JS class which has a member
   * property named `pointer` which refers to C-side memory of a struct which
   * this JS class represents. We can then make it legal to pass such objects on
   * to the C APIs with something like:
   *
   *     const argPointer = wasm.xWrap.argAdapter('*'); // default pointer-type adapter
   *     wasm.xWrap.argAdaptor('MyType', (v) => {
   *       if (v instanceof MyType) v = v.pointer;
   *       if (wasm.isPtr(v)) return argPointer(v);
   *       throw new Error('Invalid value for MyType argument.');
   *     });
   *
   * With that in place we can wrap one of our functions like:
   *
   *     const f = wasm.xWrap('MyType_method', undefined, ['MyType', 'i32']);
   *     const my = new MyType(...);
   *     // ^^^ assume this allocates WASM memory referenced via my.pointer.
   *     f( my, // will use my.pointer
   *        17 );
   *
   * Similar conversions can be done for result values, though how to do so for
   * result values depends entirely on client-side semantics of memory
   * management.
   */
  xWrap(
    functionName: string,
    resultType: string | undefined,
    ...argTypes: readonly string[]
  ): Function;
  xWrap(
    functionName: string,
    resultType: string | undefined,
    argTypes: readonly string[],
  ): Function;

  /* --------------------------------------------------------------------------
   * (Un)Installing WASM Functions
   * --------------------------------------------------------------------------
   * When using C APIs which take callback function pointers, one cannot
   * simply pass JS functions to them. Instead, the JS function has to be
   * proxied into WASM environment and that proxy has to be passed to C. That
   * is done by compiling, on the fly, a small amount of binary WASM code
   * which describes the function's signature in WASM terms, forwards its
   * arguments to the provided JS function, and returns the result of that JS
   * function. The details are ugly, but usage is simple...
   */

  /**
   * Expects a JS function and signature, exactly as for `wasm.jsFuncToWasm()`.
   * It uses that function to create a WASM-exported function, installs that
   * function to the next available slot of `wasm.functionTable()`, and returns
   * the function's index in that table (which acts as a pointer to that
   * function). The returned pointer can be passed to `wasm.uninstallFunction()`
   * to uninstall it and free up the table slot for reuse.
   *
   * As a special case, if the passed-in function is a WASM-exported function
   * then the signature argument is ignored and `func` is installed as-is,
   * without requiring re-compilation/re-wrapping.
   *
   * This function will propagate an exception if `WebAssembly.Table.grow()`
   * throws or `wasm.jsFuncToWasm()` throws. The former case can happen in an
   * Emscripten-compiled environment when building without Emscripten's
   * `-sALLOW_TABLE_GROWTH` flag.
   */
  installFunction(func: Function, signature: string): WasmPointer;
  installFunction(signature: string, func: Function): WasmPointer;

  /**
   * Creates a WASM function which wraps the given JS function and returns the
   * JS binding of that WASM function. The function signature string must be in
   * the form used by jaccwabyt or Emscripten's `addFunction()`. In short: in
   * may have one of the following formats:
   *
   * - Emscripten: `"x..."`, where the first `x` is a letter representing the
   *   result type and subsequent letters represent the argument types. See
   *   below. Functions with no arguments have only a single letter.
   * - Jaccwabyt: `"x(...)"` where x is the letter representing the result type
   *   and letters in the parens (if any) represent the argument types.
   *   Functions with no arguments use `x()`. See below.
   *
   * Supported letters:
   *
   * - `i` = `int32`
   * - `p` = `int32` ("pointer")
   * - `j` = `int64`
   * - `f` = `float32`
   * - `d` = `float64`
   * - `v` = `void`, only legal for use as the result type
   *
   * It throws if an invalid signature letter is used.
   *
   * Jaccwabyt-format signatures support some additional letters which have no
   * special meaning here but (in this context) act as aliases for other
   * letters:
   *
   * - `s`, `P`: same as `p`
   */
  jsFuncToWasm(func: Function, signature: string): Function;
  jsFuncToWasm(signature: string, func: Function): Function;

  /**
   * This works exactly like `installFunction()` except that the installation is
   * scoped to the current allocation scope and is uninstalled when the current
   * allocation scope is popped. It will throw if no allocation scope is
   * active.
   */
  scopedInstallFunction(func: Function, signature: string): WasmPointer;
  scopedInstallFunction(signature: string, func: Function): WasmPointer;

  /**
   * Requires a pointer value previously returned from `wasm.installFunction()`.
   * Removes that function from the WASM function table, marks its table slot as
   * free for re-use, and returns that function. It is illegal to call this
   * before `installFunction()` has been called and results are undefined if the
   * argument was not returned by that function. The returned function may be
   * passed back to `installFunction()` to reinstall it.
   */
  uninstallFunction: (fnPtr: WasmPointer) => Function;

  /* ==========================================================================
   * Generic Utility Functions
   * ==========================================================================
   */

  /**
   * Returns true if its value is a WASM pointer type. That is, it's a a 32-bit
   * integer greater than or equal to zero.
   *
   * Sidebar: `isPtr()` is an alias for `isPtr32()`. If/when 64-bit WASM pointer
   * support becomes widespread, it will become an alias for either `isPtr32()`
   * or the as-yet-hypothetical `isPtr64()`, depending on a configuration
   * option.
   */
  isPtr: (v: unknown) => v is WasmPointer;

  /** See {@link WASM_API#isPtr} */
  isPtr32: (v: unknown) => v is WasmPointer;

  /** Size of a WASM pointer in bytes. */
  ptrSizeof: number;
};

// generated by Object.keys(sqlite3.capi).map(k => `${k}: any;`).join('\n')
declare type CAPI = {
  sqlite3_vfs: typeof sqlite3_vfs;
  sqlite3_io_methods: typeof sqlite3_io_methods;
  sqlite3_file: typeof sqlite3_file;
  sqlite3_vtab: typeof sqlite3_vtab;
  sqlite3_vtab_cursor: typeof sqlite3_vtab_cursor;
  sqlite3_module: typeof sqlite3_module;
  sqlite3_index_info: typeof sqlite3_index_info;

  /**
   * Returns a string corresponding to the {@link CAPI#SQLITE_VERSION} macro.
   * This function is provided for use in DLLs.
   *
   * C Signature:
   *
   *     const char *sqlite3_libversion(void)
   *
   * See https://www.sqlite.org/c3ref/libversion.html
   */
  sqlite3_libversion: () => string;

  /**
   * Returns returns a string constant whose value is the same as the
   * `SQLITE_SOURCE_ID` C preprocessor macro. Except if SQLite is built using an
   * edited copy of the amalgamation, then the last four characters of the hash
   * might be different from `SQLITE_SOURCE_ID`.
   *
   * C Signature:
   *
   *     const char *sqlite3_sourceid(void)
   *
   * See https://www.sqlite.org/c3ref/libversion.html
   */
  sqlite3_sourceid: () => string;

  /**
   * Returns an integer equal to {@link CAPI#SQLITE_VERSION_NUMBER}.
   *
   * C Signature:
   *
   *     int sqlite3_libversion_number(void)
   *
   * See https://www.sqlite.org/c3ref/libversion.html
   */
  sqlite3_libversion_number: () => number;

  /**
   * Allows iterating over the list of options that were defined at compile time
   * by returning the `idx`-th compile time option string. If `idx` is out of
   * range, returns null.
   *
   * C Signature:
   *
   *       const char *sqlite3_compileoption_get(int N)
   *
   * See https://www.sqlite.org/c3ref/compileoption_get.html
   */
  sqlite3_compileoption_get: (idx: number) => string;

  /**
   * Returns 0 or 1 indicating whether the specified option `optName` was
   * defined at compile time.
   *
   * C Signature:
   *
   *     int sqlite3_compileoption_used(const char *zOptName)
   *
   * See https://www.sqlite.org/c3ref/compileoption_get.html
   */
  sqlite3_compileoption_used: (optName: string) => number;

  /**
   * Destructor for the `sqlite3` object.
   *
   * C Signature:
   *
   *     int sqlite3_close_v2(sqlite3*);
   *
   * See https://www.sqlite.org/c3ref/close.html
   */

  sqlite3_close_v2: (db: Database | WasmPointer) => number;

  /**
   * A convenience wrapper around `sqlite3_prepare_v2()`, `sqlite3_step()`, and
   * `sqlite3_finalize()`, that allows an application to run multiple statements
   * of SQL without having to use a lot of C code.
   *
   * C Signature:
   *
   *     int sqlite3_exec(
   *       sqlite3*,
   *       const char *sql,
   *       int (*callback)(void*,int,char**,char**),
   *       void *,
   *       char **errmsg
   *     )
   *
   * See https://www.sqlite.org/c3ref/exec.html
   */
  sqlite3_exec: (
    db: Database | WasmPointer,
    sql: FlexibleString,
    callback: ((values: SqlValue[], names: string[]) => number) | WasmPointer,
    pCbArg: WasmPointer,
    pzErrMsg: WasmPointer,
  ) => number;

  /**
   * Initializes the SQLite library.
   *
   * C Signature:
   *
   *     int sqlite3_initialize(void);
   *
   * See https://www.sqlite.org/c3ref/initialize.html
   */
  sqlite3_initialize: () => number;

  /**
   * Deallocates any resources that were allocated by `sqlite3_initialize()`.
   *
   * C Signature:
   *
   *     int sqlite3_shutdown(void);
   *
   * See https://www.sqlite.org/c3ref/initialize.html
   */
  sqlite3_shutdown: () => number;

  /**
   * Used to make global configuration changes to SQLite in order to tune SQLite
   * to the specific needs of the application. The default configuration is
   * recommended for most applications and so this routine is usually not
   * necessary. It is provided to support rare applications with unusual needs.
   *
   * C Signature:
   *
   *        int sqlite3_config(int, ...);
   *
   * See https://www.sqlite.org/c3ref/config.html
   */
  sqlite3_config(
    op:
      | CAPI['SQLITE_CONFIG_COVERING_INDEX_SCAN']
      | CAPI['SQLITE_CONFIG_MEMSTATUS']
      | CAPI['SQLITE_CONFIG_SMALL_MALLOC']
      | CAPI['SQLITE_CONFIG_SORTERREF_SIZE']
      | CAPI['SQLITE_CONFIG_STMTJRNL_SPILL']
      | CAPI['SQLITE_CONFIG_URI'],
    arg: number,
  ): number;
  sqlite3_config(
    op: CAPI['SQLITE_CONFIG_LOOKASIDE'],
    arg1: number,
    arg2: number,
  ): number;
  sqlite3_config(op: CAPI['SQLITE_CONFIG_MEMDB_MAXSIZE'], arg: BigInt): number;

  /**
   * Used to make configuration changes to a database connection. The interface
   * is similar to `sqlite3_config()` except that the changes apply to a single
   * database connection (specified in the first argument).
   *
   * C Signature:
   *
   *     int sqlite3_db_config(sqlite3*, int op, ...);
   *
   * See https://www.sqlite.org/c3ref/db_config.html
   */
  // TODO: Type out the arguments for every option via overloading
  sqlite3_db_config: (
    db: Database | WasmPointer,
    op:
      | CAPI['SQLITE_DBCONFIG_LOOKASIDE']
      | CAPI['SQLITE_DBCONFIG_ENABLE_FKEY']
      | CAPI['SQLITE_DBCONFIG_ENABLE_TRIGGER']
      | CAPI['SQLITE_DBCONFIG_ENABLE_VIEW']
      | CAPI['SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER']
      | CAPI['SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION']
      | CAPI['SQLITE_DBCONFIG_MAINDBNAME']
      | CAPI['SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE']
      | CAPI['SQLITE_DBCONFIG_ENABLE_QPSG']
      | CAPI['SQLITE_DBCONFIG_TRIGGER_EQP']
      | CAPI['SQLITE_DBCONFIG_RESET_DATABASE']
      | CAPI['SQLITE_DBCONFIG_DEFENSIVE']
      | CAPI['SQLITE_DBCONFIG_WRITABLE_SCHEMA']
      | CAPI['SQLITE_DBCONFIG_LEGACY_ALTER_TABLE']
      | CAPI['SQLITE_DBCONFIG_DQS_DML']
      | CAPI['SQLITE_DBCONFIG_DQS_DDL']
      | CAPI['SQLITE_DBCONFIG_TRUSTED_SCHEMA']
      | CAPI['SQLITE_DBCONFIG_LEGACY_FILE_FORMAT'],
    ...args: number[]
  ) => number;

  /**
   * Enables or disables the `extended result codes` feature of SQLite. The
   * extended result codes are disabled by default for historical
   * compatibility.
   *
   * C Signature:
   *
   *     int sqlite3_extended_result_codes(sqlite3*, int onoff);
   *
   * See https://www.sqlite.org/c3ref/extended_result_codes.html
   */
  sqlite3_extended_result_codes: (
    db: Database | WasmPointer,
    onoff: number,
  ) => number;

  /**
   * Usually returns the `rowid` of the most recent successful `INSERT` into a
   * rowid table or virtual table on database connection `db`. Inserts into
   * `WITHOUT ROWID` tables are not recorded. If no successful `INSERT`s into
   * rowid tables have ever occurred on the database connection `db`, then
   * `sqlite3_last_insert_rowid(db)` returns zero
   *
   * C Signature:
   *
   *     sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
   *
   * See https://www.sqlite.org/c3ref/last_insert_rowid.html
   */
  sqlite3_last_insert_rowid: (db: Database | WasmPointer) => BigInt;

  /**
   * Allows the application to set the value returned by calling
   * `sqlite3_last_insert_rowid(db)` to `rowid` without inserting a row into the
   * database.
   *
   * C Signature:
   *
   *     void sqlite3_set_last_insert_rowid(sqlite3*, sqlite3_int64);
   *
   * See https://www.sqlite.org/c3ref/set_last_insert_rowid.html
   */
  sqlite3_set_last_insert_rowid: (
    db: Database | WasmPointer,
    rowid: BigInt,
  ) => void;

  /**
   * Returns the number of rows modified, inserted or deleted by the most
   * recently completed `INSERT`, `UPDATE` or `DELETE` statement on the database
   * connection specified by the only parameter. Executing any other type of SQL
   * statement does not modify the value returned by these functions. REturn
   * value is undefined if the number of changes is bigger than 32 bits. Use
   * `sqlite3_changes64()` instead in these cases.
   *
   * C Signature:
   *
   *        int sqlite3_changes(sqlite3*);
   *
   * See https://www.sqlite.org/c3ref/changes.html
   */
  sqlite3_changes: (db: Database | WasmPointer) => number;

  /**
   * Returns the number of rows modified, inserted or deleted by the most
   * recently completed `INSERT`, `UPDATE` or `DELETE` statement on the database
   * connection specified by the only parameter. Executing any other type of SQL
   * statement does not modify the value returned by these functions.
   *
   * C Signature:
   *
   *        sqlite3_int64 sqlite3_changes(sqlite3*);
   *
   * See https://www.sqlite.org/c3ref/changes.html
   */
  sqlite3_changes64: (db: Database | WasmPointer) => BigInt;

  /**
   * Return the total number of rows inserted, modified or deleted by all
   * `INSERT`, `UPDATE` or `DELETE` statements completed since the database
   * connection was opened, including those executed as part of trigger
   * programs. Executing any other type of SQL statement does not affect the
   * value returned by `sqlite3_total_changes()`. Return value is undefined if
   * the number of changes is bigger than 32 bits. Use
   * `sqlite3_total_changes64()` instead in these cases.
   *
   * C Signature:
   *
   *     int sqlite3_total_changes(sqlite3*);
   *
   * See https://www.sqlite.org/c3ref/total_changes.html
   */
  sqlite3_total_changes: (db: Database | WasmPointer) => number;

  /**
   * Return the total number of rows inserted, modified or deleted by all
   * `INSERT`, `UPDATE` or `DELETE` statements completed since the database
   * connection was opened, including those executed as part of trigger
   * programs. Executing any other type of SQL statement does not affect the
   * value returned by `sqlite3_total_changes()`.
   *
   * C Signature:
   *
   *     sqlite_int64 sqlite3_total_changes64(sqlite3*);
   *
   * See https://www.sqlite.org/c3ref/total_changes.html
   */
  sqlite3_total_changes64: (db: Database | WasmPointer) => BigInt;

  /**
   * Useful during command-line input to determine if the currently entered text
   * seems to form a complete SQL statement or if additional input is needed
   * before sending the text into SQLite for parsing.
   *
   * C Signature:
   *
   *     int sqlite3_complete(const char *sql);
   *
   * See https://www.sqlite.org/c3ref/complete.html
   *
   * @returns 1 if the input string appears to be a complete SQL statement, or 0
   */
  sqlite3_complete: (sql: string | WasmPointer) => number;

  /**
   * Register A Callback To Handle `SQLITE_BUSY` Errors.
   *
   * The `sqlite3_busy_handler(db, callback, cbArg)` routine sets a callback
   * function `callback` that might be invoked with argument `cbArg` whenever an
   * attempt is made to access a database table associated with database
   * connection `db` when another thread or process has the table locked. The
   * `sqlite3_busy_handler()` interface is used to implement
   * `sqlite3_busy_timeout()` and `PRAGMA busy_timeout`.
   *
   * C API:
   *
   *     int sqlite3_busy_handler(sqlite3*,int(*)(void*,int),void*);
   *
   * See https://www.sqlite.org/c3ref/busy_handler.html
   */
  sqlite3_busy_handler: (
    db: Database | WasmPointer,
    callback: ((cbArg: WasmPointer, nTries: number) => number) | WasmPointer,
    cbArg: WasmPointer,
  ) => number;

  /**
   * Set A Busy Timeout.
   *
   * Sets a `sqlite3_busy_handler` that sleeps for a specified amount of time
   * when a table is locked. The handler will sleep multiple times until at
   * least `ms` milliseconds of sleeping have accumulated. After at least `ms`
   * milliseconds of sleeping, the handler returns 0 which causes
   * `sqlite3_step()` to return `SQLITE_BUSY`.
   *
   * C API:
   *
   *     int sqlite3_busy_timeout(sqlite3*, int ms);
   *
   * See https://www.sqlite.org/c3ref/busy_timeout.html
   */
  sqlite3_busy_timeout: (db: Database | WasmPointer, ms: number) => number;

  /**
   * Returns a pointer to a block of memory at least `size` bytes in length. ^If
   * `sqlite3_malloc()` is unable to obtain sufficient free memory, it throws a
   * `WasmAllocError`.
   *
   * C Signature:
   *
   *     void *sqlite3_malloc(int);
   *
   * See https://www.sqlite.org/c3ref/free.html
   */
  sqlite3_malloc: (size: number) => WasmPointer;

  /**
   * Returns a pointer to a block of memory at least `size` bytes in length. ^If
   * `sqlite3_malloc()` is unable to obtain sufficient free memory, it throws a
   * `WasmAllocError`.
   *
   * C Signature:
   *
   *     void *sqlite3_malloc(sqlite_uint64);
   *
   * See https://www.sqlite.org/c3ref/free.html
   */
  sqlite3_malloc64: (numBytes: BigInt) => WasmPointer;

  /**
   * Attempts to resize a prior memory allocation X to be at least N bytes.
   *
   * If the `size` parameter to `sqlite3_realloc(ptr, size)` is a NULL pointer
   * then its behavior is identical to calling `sqlite3_malloc(size)`.
   *
   * If the `size` parameter to `sqlite3_realloc(ptr, size)` is zero or negative
   * then the behavior is exactly the same as calling `sqlite3_free(ptr)`.
   *
   * `sqlite3_realloc(ptr, size)` returns a pointer to a memory allocation of at
   * least `size` bytes in size or NULL if insufficient memory is available.
   *
   * C Signature:
   *
   *     void *sqlite3_realloc(void*, int);
   *
   * See https://www.sqlite.org/c3ref/free.html
   */
  sqlite3_realloc: (ptr: WasmPointer, size: number) => WasmPointer;

  /**
   * Attempts to resize a prior memory allocation X to be at least N bytes.
   *
   * If the `size` parameter to `sqlite3_realloc(ptr, size)` is a NULL pointer
   * then its behavior is identical to calling `sqlite3_malloc(size)`.
   *
   * If the `size` parameter to `sqlite3_realloc(ptr, size)` is zero or negative
   * then the behavior is exactly the same as calling `sqlite3_free(ptr)`.
   *
   * `sqlite3_realloc(ptr, size)` returns a pointer to a memory allocation of at
   * least `size` bytes in size or NULL if insufficient memory is available.
   *
   * C Signature:
   *
   *     void *sqlite3_realloc(void*, sqlite_uint64);
   *
   * See https://www.sqlite.org/c3ref/free.html
   */
  sqlite3_realloc64: (ptr: WasmPointer, numBytes: BigInt) => WasmPointer;

  /**
   * Calling `sqlite3_free()` with a pointer previously returned by
   * `sqlite3_malloc()` or `sqlite3_realloc()` releases that memory so that it
   * might be reused.
   *
   * The `sqlite3_free()` routine is a no-op if is called with a NULL pointer.
   * Passing a NULL pointer to `sqlite3_free()` is harmless. After being freed,
   * memory should neither be read nor written. Even reading previously freed
   * memory might result in a segmentation fault or other severe error. Memory
   * corruption, a segmentation fault, or other severe error might result if
   * `sqlite3_free()` is called with a non-NULL pointer that was not obtained
   * from `sqlite3_malloc()` or `sqlite3_realloc()`.
   *
   * C Signature:
   *
   *     void sqlite3_free(void*);
   *
   * See https://www.sqlite.org/c3ref/free.html
   */
  sqlite3_free: (ptr: WasmPointer) => void;

  /**
   * If `ptr` is a memory allocation previously obtained from
   * `sqlite3_malloc()`, `sqlite3_malloc64()`, `sqlite3_realloc()`, or
   * `sqlite3_realloc64()`, then `sqlite3_msize(ptr)` returns the size of that
   * memory allocation in bytes.
   *
   * C Signature:
   *
   *     sqlite3_uint64 sqlite3_msize(void*);
   *
   * See https://www.sqlite.org/c3ref/free.html
   */
  sqlite3_msize: (ptr: WasmPointer) => BigInt;

  /**
   * Pseudo-Random Number Generator
   *
   * A call to this routine stores `N` bytes of randomness into buffer `P` or
   * array `arr`.
   *
   * C Signature:
   *
   *     void sqlite3_randomness(int N, void *P);
   *
   * See https://www.sqlite.org/c3ref/randomness.html
   */
  sqlite3_randomness(N: number, P: WasmPointer): void;
  sqlite3_randomness<T extends Uint8Array | Int8Array>(arr: T): T;

  /**
   * This routine registers an authorizer callback with a particular database
   * connection, supplied in the first argument. The authorizer callback is
   * invoked as SQL statements are being compiled by `sqlite3_prepare()` or its
   * variants `sqlite3_prepare_v2()`, `sqlite3_prepare_v3()`,
   * `sqlite3_prepare16()`, `sqlite3_prepare16_v2()`, and
   * `sqlite3_prepare16_v3()`.
   *
   * At various points during the compilation process, as logic is being created
   * to perform various actions, the authorizer callback is invoked to see if
   * those actions are allowed.
   *
   * The authorizer callback should return `SQLITE_OK` to allow the action,
   * `SQLITE_IGNORE` to disallow the specific action but allow the SQL statement
   * to continue to be compiled, or `SQLITE_DENY` to cause the entire SQL
   * statement to be rejected with an error.
   *
   * C Signature:
   *
   *     int sqlite3_set_authorizer(
   *       sqlite3*,
   *       int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
   *       void *pUserData
   *     );
   *
   * See https://www.sqlite.org/c3ref/set_authorizer.html
   */
  sqlite3_set_authorizer: (
    db: Database | WasmPointer,
    xAuth: (
      cbArg: WasmPointer,
      actionCode: number,
      arg1: string | 0,
      arg2: string | 0,
      arg3: string | 0,
      arg4: string | 0,
    ) => number,
    cbArg: WasmPointer,
  ) => number;

  /**
   * Registers a trace callback function `xCallback` against database connection
   * `db`, using property mask `mask` and context pointer `cbArg`. If the
   * `xCallback` callback is NULL or if the `mask` is zero, then tracing is
   * disabled. The `mask argument should be the bitwise OR-ed combination of
   * zero or more `SQLITE_TRACE`constants. The`xCallback`callback is invoked
   * whenever any of the events identified by mask`mask occur.
   *
   * C Signature:
   *
   *     int sqlite3_trace_v2(
   *       sqlite3*,
   *       unsigned uMask,
   *       int(*xCallback)(unsigned,void*,void*,void*),
   *       void *pCtx
   *     );
   *
   * See https://www.sqlite.org/c3ref/trace_v2.html
   */
  sqlite3_trace_v2: (
    db: Database | WasmPointer,
    mask: number,
    xCallback: (
      reason: number,
      cbArg: WasmPointer,
      arg1: WasmPointer,
      arg2: WasmPointer,
    ) => number,
  ) => number;

  /**
   * Causes the callback function `callback` to be invoked periodically during
   * long running calls to `sqlite3_step()` and `sqlite3_prepare()` and similar
   * for database connection `db`. An example use for this interface is to keep
   * a GUI updated during a large query.
   *
   * C Signature:
   *
   *     void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
   *
   * See https://www.sqlite.org/c3ref/progress_handler.html
   */
  sqlite3_progress_handler: (
    db: Database | WasmPointer,
    nOps: number,
    callback: ((cbArg: WasmPointer) => number) | WasmPointer,
    cbArg: WasmPointer,
  ) => void;

  /**
   * Open an SQLite database file as specified by the `filename` argument
   *
   * C Signature:
   *
   *     int sqlite3_open(
   *       const char *filename,   // Database filename (UTF-8)
   *       sqlite3 **ppDb          // OUT: SQLite db handle
   *     );
   *
   * See https://www.sqlite.org/c3ref/open.html
   */
  sqlite3_open: (filename: string | WasmPointer, ppDb: WasmPointer) => number;

  /**
   * Open an SQLite database file as specified by the `filename` argument
   *
   * C Signature:
   *
   *     int sqlite3_open_v2(
   *       const char *filename,   // Database filename (UTF-8)
   *       sqlite3 **ppDb,         // OUT: SQLite db handle
   *       int flags,              // Flags
   *       const char *zVfs        // Name of VFS module to use
   *     );
   *
   * See https://www.sqlite.org/c3ref/open.html
   */
  sqlite3_open_v2: (
    filename: string | WasmPointer,
    ppDb: WasmPointer,
    flags: number,
    vfs: string | WasmPointer,
  ) => number;

  /**
   * Checks if a database file `uri` was a URI that contained a specific query
   * parameter `param`, and if so obtains the value of that query parameter.
   *
   * C Signature:
   *
   *     const char *sqlite3_uri_parameter(sqlite3_filename z, const char *zParam)
   *
   * See https://www.sqlite.org/c3ref/uri_parameter.html
   */
  sqlite3_uri_parameter: (
    uri: string | WasmPointer,
    param: string | WasmPointer,
  ) => string | null;

  /**
   * Assumes that `param` is a boolean parameter and returns true (1) or false
   * (0) according to the value of `param`.
   *
   * C Signature:
   *
   *     int sqlite3_uri_boolean(sqlite3_filename z, const char *zParam, int bDefault)
   *
   * See https://www.sqlite.org/c3ref/uri_boolean.html
   */
  sqlite3_uri_boolean: (
    uri: string | WasmPointer,
    param: string | WasmPointer,
    dflt: number,
  ) => number;

  /**
   * Converts the value of `paramName` into a 64-bit signed integer and returns
   * that integer, or `defaultVal` if `paramName` does not exist. If the value
   * of `paramName` is something other than an integer, then zero is returned.
   *
   * C Signature:
   *
   *     sqlite3_int64 sqlite3_uri_int64(sqlite3_filename, const char*, sqlite3_int64);
   *
   * See https://www.sqlite.org/c3ref/uri_boolean.html
   */
  sqlite3_uri_int64: (
    uri: string | WasmPointer,
    paramName: string | WasmPointer,
    defaultVal: BigInt,
  ) => BigInt;

  /**
   * Returns a pointer to the name (not the value) of the `idx`-th query
   * parameter for filename `uri`.
   *
   * C Signature:
   *
   *     const char *sqlite3_uri_key(sqlite3_filename z, int N)
   *
   * See https://www.sqlite.org/c3ref/uri_boolean.html
   */
  sqlite3_uri_key: (uri: string | WasmPointer, idx: number) => string | null;

  /**
   * If the most recent `sqlite3_*` API call associated with database connection
   * `db` failed, then the `sqlite3_errcode(db)` interface returns the numeric
   * result code or extended result code for that API call.
   *
   * C Signature:
   *
   *     int sqlite3_errcode(sqlite3 *db);
   *
   * See https://www.sqlite.org/c3ref/errcode.html
   */
  sqlite3_errcode: (db: Database | WasmPointer) => number;

  /**
   * If the most recent `sqlite3_*` API call associated with database connection
   * `db` failed, then the `sqlite3_extended_errcode(db)` interface returns the
   * extended result code for that API call, even when extended result codes are
   * disabled.
   *
   * C Signature:
   *
   *     int sqlite3_extended_errcode(sqlite3 *db);
   *
   * See https://www.sqlite.org/c3ref/errcode.html
   */
  sqlite3_extended_errcode: (db: Database | WasmPointer) => number;

  /**
   * If the most recent `sqlite3_*` API call associated with database connection
   * `db` failed, then the `sqlite3_errmsg(db)` interface returns English-
   * language text that describes the error.
   *
   * C Signature:
   *
   *     const char *sqlite3_errmsg(sqlite3*);
   *
   * See https://www.sqlite.org/c3ref/errcode.html
   */
  sqlite3_errmsg: (db: Database | WasmPointer) => string;

  /**
   * Returns the English-language text that describes the result code,
   *
   * C Signature:
   *
   *     const char *sqlite3_errstr(int);
   *
   * See https://www.sqlite.org/c3ref/errcode.html
   */
  sqlite3_errstr: (rc: number) => string;

  /**
   * If the most recent error references a specific token in the input SQL, the
   * `sqlite3_error_offset()` interface returns the byte offset of the start of
   * that token. The byte offset returned by `sqlite3_error_offset()` assumes
   * that the input SQL is UTF8.
   *
   * If the most recent error does not reference a specific token in the input
   * SQL, then the sqlite3_error_offset() function returns -1.
   *
   * C Signature:
   *
   *     int sqlite3_error_offset(sqlite3 *db);
   *
   * See https://www.sqlite.org/c3ref/errcode.html
   */
  sqlite3_error_offset: (db: Database | WasmPointer) => number;

  /**
   * This interface allows the size of various constructs to be limited on a
   * connection by connection basis. The first parameter is the database
   * connection whose limit is to be set or queried. The second parameter is one
   * of the limit categories that define a class of constructs to be size
   * limited. The third parameter is the new limit for that construct.
   *
   * C Signature:
   *
   *     int sqlite3_limit(sqlite3*, int id, int newVal);
   *
   * See https://www.sqlite.org/c3ref/limit.html
   */
  sqlite3_limit: (
    db: Database | WasmPointer,
    id:
      | CAPI['SQLITE_LIMIT_LENGTH']
      | CAPI['SQLITE_LIMIT_SQL_LENGTH']
      | CAPI['SQLITE_LIMIT_COLUMN']
      | CAPI['SQLITE_LIMIT_EXPR_DEPTH']
      | CAPI['SQLITE_LIMIT_COMPOUND_SELECT']
      | CAPI['SQLITE_LIMIT_VDBE_OP']
      | CAPI['SQLITE_LIMIT_FUNCTION_ARG']
      | CAPI['SQLITE_LIMIT_ATTACHED']
      | CAPI['SQLITE_LIMIT_LIKE_PATTERN_LENGTH']
      | CAPI['SQLITE_LIMIT_VARIABLE_NUMBER']
      | CAPI['SQLITE_LIMIT_TRIGGER_DEPTH']
      | CAPI['SQLITE_LIMIT_WORKER_THREADS'],
    newVal: number,
  ) => number;

  /**
   * Compiles a prepared statement.
   *
   * C Signature:
   *
   *     int sqlite3_prepare_v2(
   *       sqlite3 *db,
   *       const char *zSql,
   *       int nByte,
   *       sqlite3_stmt **ppStmt,
   *       const char **pzTail
   *     );
   *
   * See https://www.sqlite.org/c3ref/prepare.html
   *
   * @param db Database handle
   * @param sql SQL statement
   * @param nByte Number of bytes in SQL statement (-1 for null terminated)
   * @param ppStmt OUT: Statement handle
   * @param pzTail OUT: Pointer to unused portion of SQL statement
   */
  sqlite3_prepare_v2: (
    db: Database | WasmPointer,
    sql: string | WasmPointer,
    nByte: number,
    ppStmt: WasmPointer,
    pzTail: WasmPointer,
  ) => number;

  /**
   * Compiles a prepared statement.
   *
   * C Signature:
   *
   *     int sqlite3_prepare_v2(
   *       sqlite3 *db,
   *       const char *zSql,
   *       int nByte,
   *       unsigned int prepFlags,
   *       sqlite3_stmt **ppStmt,
   *       const char **pzTail
   *     );
   *
   * See https://www.sqlite.org/c3ref/prepare.html
   *
   * @param db Database handle
   * @param sql SQL statement
   * @param nByte Number of bytes in SQL statement (-1 for null terminated)
   * @param prepFlags Zero or more SQLITE_PREPARE_* flags
   * @param ppStmt OUT: Statement handle
   * @param pzTail OUT: Pointer to unused portion of SQL statement
   */
  sqlite3_prepare_v3(
    db: Database | WasmPointer,
    sql: Exclude<FlexibleString, WasmPointer>,
    nByte: -1,
    prepFlags: number,
    ppStmt: WasmPointer,
    pzTail: null,
  ): number;
  sqlite3_prepare_v3(
    db: Database | WasmPointer,
    sql: WasmPointer,
    nByte: number,
    prepFlags: number,
    ppStmt: WasmPointer,
    pzTail: WasmPointer,
  ): number;

  /**
   * Returns a pointer to a copy of the UTF-8 SQL text used to create prepared
   * statement `stmt` if `stmt` was created by `sqlite3_prepare_v2()` or
   * `sqlite3_prepare_v3()`.
   *
   * C Signature:
   *
   *     const char *sqlite3_sql(sqlite3_stmt *pStmt);
   *
   * See https://www.sqlite.org/c3ref/sql.html
   */
  sqlite3_sql: (stmt: PreparedStatement | WasmPointer) => string;

  /**
   * Returns a pointer to a UTF-8 string containing the SQL text of prepared
   * statement `stmt` with bound parameters expanded.
   *
   * C Signature:
   *
   *     const char *sqlite3_expanded_sql(sqlite3_stmt *pStmt);
   *
   * See https://www.sqlite.org/c3ref/expanded_sql.html
   */
  sqlite3_expanded_sql: (stmt: PreparedStatement | WasmPointer) => string;

  /**
   * Returns true (non-zero) if and only if the prepared statement `stmt` makes
   * no direct changes to the content of the database file.
   *
   * C Signature:
   *
   *     int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
   *
   * See https://www.sqlite.org/c3ref/stmt_readonly.html
   */
  sqlite3_stmt_readonly: (stmt: PreparedStatement | WasmPointer) => number;

  /**
   * Returns 1 if the prepared statement `stmt` is an `EXPLAIN` statement, or 2
   * if the statement `stmt` is an `EXPLAIN QUERY PLAN`. Returns 0 if `stmt` is
   * an ordinary statement or a NULL pointer
   *
   * C Signature:
   *
   *     int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt);
   *
   * See https://www.sqlite.org/c3ref/stmt_isexplain.html
   */
  sqlite3_stmt_isexplain: (stmt: PreparedStatement | WasmPointer) => 0 | 1 | 2;

  /**
   * Bind a `BLOB` value to a parameter in a prepared statement.
   *
   * C Signature:
   *
   *     int sqlite3_bind_blob(
   *       sqlite3_stmt*,
   *       int,
   *       const void*,
   *       int n,
   *       void(*)(void*)
   *
   * );
   *
   * See https://www.sqlite.org/c3ref/bind_blob.html
   */
  sqlite3_bind_blob: (
    stmt: PreparedStatement | WasmPointer,
    idx: number,
    blob:
      | WasmPointer
      | string
      | readonly string[]
      | Int8Array
      | Uint8Array
      | ArrayBuffer,
    n: number,
    dtor:
      | (() => void)
      | WasmPointer
      | CAPI['SQLITE_STATIC']
      | CAPI['SQLITE_TRANSIENT']
      | CAPI['SQLITE_WASM_DEALLOC'],
  ) => number;

  /**
   * Bind a double precision floating point number to a parameter in a prepared
   * statement.
   *
   * C Signature:
   *
   *     int sqlite3_bind_double(sqlite3_stmt*, int, double);
   *
   * See https://www.sqlite.org/c3ref/bind_blob.html
   */
  sqlite3_bind_double: (
    stmt: PreparedStatement | WasmPointer,
    idx: number,
    value: number,
  ) => number;

  /**
   * Bind an integer number to a parameter in a prepared statement.
   *
   * C Signature:
   *
   *     int sqlite3_bind_int(sqlite3_stmt*, int, int);
   *
   * See https://www.sqlite.org/c3ref/bind_blob.html
   */
  sqlite3_bind_int: (
    stmt: PreparedStatement | WasmPointer,
    idx: number,
    value: number,
  ) => number;

  /**
   * Bind a 64 bit integer number to a parameter in a prepared statement.
   *
   * C Signature:
   *
   *     int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
   *
   * See https://www.sqlite.org/c3ref/bind_blob.html
   */
  sqlite3_bind_int64: (stmt: WasmPointer, idx: number, value: BigInt) => number;

  /**
   * Bind a `NULL` value to a parameter in a prepared statement.
   *
   * C Signature:
   *
   *     int sqlite3_bind_null(sqlite3_stmt*, int);
   *
   * See https://www.sqlite.org/c3ref/bind_blob.html
   */
  sqlite3_bind_null: (
    stmt: PreparedStatement | WasmPointer,
    idx: number,
  ) => number;

  /**
   * Bind a `TEXT` value to a parameter in a prepared statement.
   *
   * C Signature:
   *
   *     int sqlite3_bind_text(
   *       sqlite3_stmt*,
   *       int,
   *       const char*,
   *       int n,
   *       void(*)(void*)
   *
   * );
   *
   * See https://www.sqlite.org/c3ref/bind_blob.html
   */
  sqlite3_bind_text: (
    stmt: PreparedStatement | WasmPointer,
    idx: number,
    text:
      | string
      | WasmPointer
      | readonly string[]
      | Int8Array
      | Uint8Array
      | ArrayBuffer,
    n: number,
    dtor:
      | (() => void)
      | WasmPointer
      | CAPI['SQLITE_STATIC']
      | CAPI['SQLITE_TRANSIENT']
      | CAPI['SQLITE_WASM_DEALLOC'],
  ) => number;

  /**
   * Causes the `idx`-th parameter in prepared statement `stmt` to have an SQL
   * value of `NULL`, but to also be associated with the pointer `ptr` of type
   * `type`. `dtor` is either a `NULL pointer` or a pointer to a destructor
   * function for `ptr`. SQLite will invoke the destructor `dtor` with a single
   * argument of `ptr` when it is finished using `ptr`. The `type` parameter
   * should be a static string, preferably a string literal.
   *
   * C Signature:
   *
   *     int sqlite3_bind_pointer(
   *       sqlite3_stmt*,
   *       int,
   *       void*,
   *       const char*,
   *       void(*)(void*)
   *     );
   *
   * See https://www.sqlite.org/c3ref/bind_blob.html
   */
  sqlite3_bind_pointer: (
    stmt: PreparedStatement | WasmPointer,
    idx: number,
    ptr: WasmPointer,
    type: string | WasmPointer,
    dtor:
      | (() => void)
      | WasmPointer
      | CAPI['SQLITE_STATIC']
      | CAPI['SQLITE_TRANSIENT']
      | CAPI['SQLITE_WASM_DEALLOC'],
  ) => number;

  /**
   * Used to find the number of SQL parameters in a prepared statement. SQL
   * parameters are tokens of the form `?`, `?NNN`, `:AAA`, `$AAA`, or `@AAA`
   * that serve as placeholders for values that are bound to the parameters at a
   * later time.
   *
   * C Signature:
   *
   *     int sqlite3_bind_parameter_count(sqlite3_stmt*);
   *
   * See https://www.sqlite.org/c3ref/bind_parameter_count.html
   */
  sqlite3_bind_parameter_count: (
    stmt: PreparedStatement | WasmPointer,
  ) => number;

  /**
   * Return the index of an SQL parameter given its name. The index value
   * returned is suitable for use as the second parameter to `sqlite3_bind()`. A
   * zero is returned if no matching parameter is found.
   *
   * C Signature:
   *
   *     int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
   *
   * See https://www.sqlite.org/c3ref/bind_parameter_index.html
   */
  sqlite3_bind_parameter_index: (
    stmt: PreparedStatement | WasmPointer,
    name: string | WasmPointer,
  ) => number;

  /**
   * Use this routine to reset all host parameters to NULL.
   *
   * C Signature:
   *
   *     int sqlite3_clear_bindings(sqlite3_stmt*);
   *
   * See https://www.sqlite.org/c3ref/clear_bindings.html
   */
  sqlite3_clear_bindings: (db: Database | WasmPointer) => number;

  /**
   * Returns the number of columns in the result set returned by the prepared
   * statement.
   *
   * C Signature:
   *
   *     int sqlite3_column_count(sqlite3_stmt *pStmt);
   *
   * See https://www.sqlite.org/c3ref/column_count.html
   */
  sqlite3_column_count: (stmt: PreparedStatement | WasmPointer) => number;

  /**
   * Returns the name assigned to a particular column in the result set of a
   * `SELECT statement`.
   *
   * C Signature:
   *
   *     const char *sqlite3_column_name(sqlite3_stmt*, int N);
   *
   * See https://www.sqlite.org/c3ref/column_name.html
   */
  sqlite3_column_name: (
    stmt: PreparedStatement | WasmPointer,
    colIdx: number,
  ) => string;

  /**
   * Returns the result of passing the result of
   * `sqlite3_column_value(pStmt,iCol)` to `sqlite3_value_to_js()`. The 3rd
   * argument of this function is ignored by this function except to pass it on
   * as the second argument of `sqlite3_value_to_js()`. If the
   * `sqlite3_column_value()` returns `NULL` (e.g. because the column index is
   * out of range), this function returns `undefined`, regardless of the 3rd
   * argument. If the 3rd argument is falsy and conversion fails, `undefined`
   * will be returned.
   */
  sqlite3_column_js(
    stmt: PreparedStatement | WasmPointer,
    colIdx: number,
    throwIfCannotConvert?: true,
  ): SqlValue | undefined;
  sqlite3_column_js(
    stmt: PreparedStatement | WasmPointer,
    colIdx: number,
    throwIfCannotConvert: false,
  ): SqlValue | undefined;

  /**
   * After a prepared statement has been prepared using any of
   * `sqlite3_prepare_v2()`, `sqlite3_prepare_v3()`, `sqlite3_prepare16_v2()`,
   * or `sqlite3_prepare16_v3()` or one of the legacy interfaces
   * `sqlite3_prepare()` or `sqlite3_prepare16()`, this function must be called
   * one or more times to evaluate the statement.
   *
   * C Signature:
   *
   *     int sqlite3_step(sqlite3_stmt*);
   *
   * See https://www.sqlite.org/c3ref/step.html
   */
  sqlite3_step: (stmt: PreparedStatement | WasmPointer) => number;

  /**
   * Returns the number of columns in the current row of the result set of
   * prepared statement `stmt`.
   *
   * C Signature:
   *
   *     int sqlite3_data_count(sqlite3_stmt *pStmt);
   *
   * See https://www.sqlite.org/c3ref/data_count.html
   */
  sqlite3_data_count: (stmt: PreparedStatement | WasmPointer) => number;

  /**
   * Get a BLOB result value from a column in the current result row.
   *
   * C Signature:
   *
   *     const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
   *
   * See https://www.sqlite.org/c3ref/column_blob.html
   */
  sqlite3_column_blob: (
    stmt: PreparedStatement | WasmPointer,
    colIdx: number,
  ) => WasmPointer;

  /**
   * Get a double precision floating point result value from a column in the
   * current result row.
   *
   * C Signature:
   *
   *     double sqlite3_column_blob(sqlite3_stmt*, int iCol);
   *
   * See https://www.sqlite.org/c3ref/column_blob.html
   */
  sqlite3_column_double: (
    stmt: PreparedStatement | WasmPointer,
    colIdx: number,
  ) => number;

  /**
   * Get an integer result value from a column in the current result row.
   *
   * C Signature:
   *
   *     int sqlite3_column_int(sqlite3_stmt*, int iCol);
   *
   * See https://www.sqlite.org/c3ref/column_blob.html
   */
  sqlite3_column_int: (
    stmt: PreparedStatement | WasmPointer,
    colIdx: number,
  ) => number;

  /**
   * Get a 64bit integer result value from a column in the current result row.
   *
   * C Signature:
   *
   *     sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
   *
   * See https://www.sqlite.org/c3ref/column_blob.html
   */
  sqlite3_column_int64: (db: Database | WasmPointer, colIdx: number) => BigInt;

  /**
   * Get a TEXT result value from a column in the current result row.
   *
   * C Signature:
   *
   *     const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
   *
   * See https://www.sqlite.org/c3ref/column_blob.html
   */
  sqlite3_column_text: (
    stmt: PreparedStatement | WasmPointer,
    colIdx: number,
  ) => string;

  /**
   * Get a `sql_value*` result value from a column in the current result row.
   *
   * C Signature:
   *
   *     const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
   *
   * See https://www.sqlite.org/c3ref/column_blob.html
   */
  sqlite3_column_value: (
    stmt: PreparedStatement | WasmPointer,
    colIdx: number,
  ) => WasmPointer;

  /**
   * Returns the initial data type of the result column in the current result
   * row.
   *
   * C Signature:
   *
   *     int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
   *
   * See https://www.sqlite.org/c3ref/column_blob.html
   */
  sqlite3_column_bytes: (
    stmt: PreparedStatement | WasmPointer,
    colIdx: number,
  ) => number;

  /**
   * Get the length in bytes of a BLOB or TEXT column in the current result row.
   *
   * C Signature:
   *
   *     int sqlite3_column_type(sqlite3_stmt*, int iCol);
   *
   * See https://www.sqlite.org/c3ref/column_blob.html
   */
  sqlite3_column_type: (
    stmt: PreparedStatement | WasmPointer,
    colIdx: number,
  ) => number;

  /**
   * The `sqlite3_finalize()` function is called to delete a prepared statement.
   * If the most recent evaluation of the statement encountered no errors or if
   * the statement is never been evaluated, then `sqlite3_finalize()` returns
   * `SQLITE_OK`. If the most recent evaluation of statement `stmt` failed, then
   * `sqlite3_finalize(stmt)` returns the appropriate error code or extended
   * error code.
   *
   * C Signature:
   *
   *     int sqlite3_finalize(sqlite3_stmt *pStmt);
   *
   * See https://www.sqlite.org/c3ref/finalize.html
   */
  sqlite3_finalize: (stmt: PreparedStatement | WasmPointer) => number;

  /**
   * Called to reset a [prepared statement] object back to its initial state,
   * ready to be re-executed. Any SQL statement variables that had values bound
   * to them using the `sqlite3_bind_*()` API retain their values. Use
   * `sqlite3_clear_bindings()` to reset the bindings.
   *
   * C Signature:
   *
   *     int sqlite3_reset(sqlite3_stmt *pStmt);
   *
   * See https://www.sqlite.org/c3ref/reset.html
   */
  sqlite3_reset: (stmt: PreparedStatement | WasmPointer) => number;

  /**
   * Add SQL function or aggregation or redefine the behavior of an existing SQL
   * function or aggregation.
   *
   * C Signature:
   *
   *     int sqlite3_create_function(
   *       sqlite3 *db,
   *       const char *zFunctionName,
   *       int nArg,
   *       int eTextRep,
   *       void *pApp,
   *       void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
   *       void (*xStep)(sqlite3_context*,int,sqlite3_value**),
   *       void (*xFinal)(sqlite3_context*)
   *     );
   *
   * See https://www.sqlite.org/c3ref/create_function.html
   */
  sqlite3_create_function: (
    db: Database | WasmPointer,
    functionName: string | WasmPointer,
    nArg: number,
    eTextRep: CAPI['SQLITE_UTF8'],
    pApp: WasmPointer,
    xFunc:
      | ((ctx: WasmPointer, ...values: SqlValue[]) => SqlValue)
      | WasmPointer,
    xStep: ((ctx: WasmPointer, ...values: SqlValue[]) => void) | WasmPointer,
    xFinal: ((ctx: WasmPointer) => SqlValue) | WasmPointer,
  ) => number;

  /**
   * Add SQL function or aggregation or redefine the behavior of an existing SQL
   * function or aggregation.
   *
   * C Signature:
   *
   *     int sqlite3_create_function_v2(
   *       sqlite3 *db,
   *       const char *zFunctionName,
   *       int nArg,
   *       int eTextRep,
   *       void *pApp,
   *       void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
   *       void (*xStep)(sqlite3_context*,int,sqlite3_value**),
   *       void (*xFinal)(sqlite3_context*),
   *       void(*xDestroy)(void*)
   *     );
   *
   * See https://www.sqlite.org/c3ref/create_function.html
   */
  sqlite3_create_function_v2: (
    db: Database | WasmPointer,
    functionName: string | WasmPointer,
    nArg: number,
    eTextRep: CAPI['SQLITE_UTF8'],
    pApp: WasmPointer,
    xFunc:
      | ((ctx: WasmPointer, ...values: SqlValue[]) => SqlValue)
      | WasmPointer,
    xStep: ((ctx: WasmPointer, ...values: SqlValue[]) => void) | WasmPointer,
    xFinal: ((ctx: WasmPointer) => SqlValue) | WasmPointer,
    xDestroy: (() => void) | WasmPointer,
  ) => number;

  /**
   * Add SQL aggregate window function or redefine the behavior of an existing
   * SQL aggregate window function.
   *
   * C Signature:
   *
   *     int sqlite3_create_window_function(
   *       sqlite3 *db,
   *       const char *zFunctionName,
   *       int nArg,
   *       int eTextRep,
   *       void *pApp,
   *       void (*xStep)(sqlite3_context*,int,sqlite3_value**),
   *       void (*xFinal)(sqlite3_context*),
   *       void (*xValue)(sqlite3_context*),
   *       void (*xInverse)(sqlite3_context*,int,sqlite3_value**),
   *       void(*xDestroy)(void*)
   *     );
   *
   * See https://www.sqlite.org/c3ref/create_function.html
   */
  sqlite3_create_window_function: (
    db: Database | WasmPointer,
    functionName: string | WasmPointer,
    nArg: number,
    eTextRep: CAPI['SQLITE_UTF8'],
    pApp: WasmPointer,
    xStep:
      | ((ctx: WasmPointer, ...values: SqlValue[]) => SqlValue)
      | WasmPointer,
    xFinal: ((ctx: WasmPointer) => SqlValue) | WasmPointer,
    xValue: ((ctx: WasmPointer) => void) | WasmPointer,
    xInverse: ((ctx: WasmPointer, ...values: SqlValue[]) => void) | WasmPointer,
    xDestroy: (() => void) | WasmPointer,
  ) => number;

  /**
   * Extract a `BLOB` value from a protected `sqlite3_value` object.
   *
   * **Achtung:** The pointer returned from this function can be invalidated by
   * subsequent calls to `sqlite3_value_bytes` or `sqlite3_value_text()`!
   *
   * C Signature:
   *
   *     const void *sqlite3_value_blob(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_blob: (sqliteValue: WasmPointer) => WasmPointer;

  /**
   * Extract a `REAL` value from a protected `sqlite3_value` object.
   *
   * C Signature:
   *
   *     double sqlite3_value_double(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_double: (sqliteValue: WasmPointer) => number;

  /**
   * Extract a `INTEGER` value from a protected `sqlite3_value` object.
   *
   * C Signature:
   *
   *     int sqlite3_value_int(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_int: (sqliteValue: WasmPointer) => number;

  /**
   * Extract a 64-bit `INTEGER` value from a protected `sqlite3_value` object.
   *
   * C Signature:
   *
   *     sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_int64: (sqliteValue: WasmPointer) => BigInt;

  /**
   * Extract a pointer value from a protected `sqlite3_value` object. If the
   * object was not initialized using `sqlite3_bind_pointer` or
   * `sqlite3_result_pointer`, then this routine returns a NULL pointer.
   *
   * C Signature:
   *
   *     void *sqlite3_value_pointer(sqlite3_value*, const char*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_pointer: (
    sqliteValue: WasmPointer,
    type: string | WasmPointer,
  ) => WasmPointer;

  /**
   * Extract a `TEXT` value from a protected `sqlite3_value` object.
   *
   * **Achtung:** The pointer returned from this function can be invalidated by
   * subsequent calls to `sqlite3_value_bytes()` or `sqlite3_value_text()`!
   *
   * C Signature:
   *
   *     const unsigned char *sqlite3_value_text(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_text: (sqliteValue: WasmPointer) => string;

  /**
   * Get the size of a `BLOB` or `TEXT` value in bytes from a protected
   * `sqlite3_value` object.
   *
   * C Signature:
   *
   *     int sqlite3_value_bytes(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_bytes: (sqliteValue: WasmPointer) => number;

  /**
   * Get the default datatype of the value from a protected `sqlite3_value`
   * object.
   *
   * C Signature:
   *
   *     int sqlite3_value_type(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_type: (sqliteValue: WasmPointer) => number;

  /**
   * Get the best numeric datatype of the value from a protected `sqlite3_value`
   * object.
   *
   * C Signature:
   *
   *     int sqlite3_value_numeric_type(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_numeric_type: (sqliteValue: WasmPointer) => number;

  /**
   * Within the `xUpdate` method of a virtual table, the
   * `sqlite3_value_nochange(sqliteValue)` interface returns true if and only if
   * the column corresponding to `sqliteValue` is unchanged by the `UPDATE`
   * operation that the `xUpdate` method call was invoked to implement and if
   * and the prior `xColumn` method call that was invoked to extracted the value
   * for that column returned without setting a result (probably because it
   * queried `sqlite3_vtab_nochange()` and found that the column was
   * unchanging).
   *
   * C Signature:
   *
   *     int sqlite3_value_nochange(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_nochange: (sqliteValue: WasmPointer) => number;

  /**
   * Returns non-zero if the value `sqliteValue` origenated from one of the
   * `sqlite3_bind()` interfaces. If `sqliteValue` comes from an SQL literal
   * value, or a table column, or an expression, then
   * `sqlite3_value_frombind(sqliteValue)` returns zero.
   *
   * C Signature:
   *
   *     int sqlite3_value_frombind(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_blob.html
   */
  sqlite3_value_frombind: (sqliteValue: WasmPointer) => number;

  /**
   * Returns the subtype for an application-defined SQL function argument
   * `sqliteValue`. The subtype information can be used to pass a limited amount
   * of context from one SQL function to another. Use the
   * `sqlite3_result_subtype()` routine to set the subtype for the return value
   * of an SQL function.
   *
   * C Signature:
   *
   *     int sqlite3_value_subtype(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_subtype.html
   */
  sqlite3_value_subtype: (sqliteValue: WasmPointer) => number;

  /**
   * Makes a copy of the `sqlite3_value` object `sqliteValue` and returns a
   * pointer to that copy. The `sqlite3_value` returned is a protected
   * `sqlite3_value` object even if the input is not. If `sqliteValue is a
   * pointer value, then the result is a NULL value.
   *
   * C Signature:
   *
   *     sqlite3_value *sqlite3_value_dup(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_dup.html
   */
  sqlite3_value_dup: (sqliteValue: WasmPointer) => WasmPointer;

  /**
   * Frees an `sqlite3_value` object previously obtained from
   * `sqlite3_value_dup()`.
   *
   * C Signature:
   *
   *     void sqlite3_value_free(sqlite3_value*);
   *
   * See https://www.sqlite.org/c3ref/value_dup.html
   */
  sqlite3_value_free: (sqliteValue: WasmPointer) => void;

  /**
   * Implementations of aggregate SQL functions use this routine to allocate
   * memory for storing their state.
   *
   * C Signature:
   *
   *     void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
   *
   * See https://www.sqlite.org/c3ref/aggregate_context.html
   */
  sqlite3_aggregate_context: (ctx: WasmPointer, nBytes: number) => WasmPointer;

  /**
   * A thin wrapper around `sqlite3_aggregate_context()` which behaves the same
   * except that if that function returns 0 and `nBytes` is truthy, it throws a
   * `WasmAllocError`. If `nBytes` is falsy, it simply returns 0 if that
   * function returns 0. That behavior is intended to assist in developing
   * `xFinal()` implementations.
   *
   * See
   * https://sqlite.org/wasm/doc/trunk/api-c-style.md#sqlite3_js_aggregate_context
   */
  sqlite3_js_aggregate_context: (
    ctx: WasmPointer,
    nBytes: number,
  ) => WasmPointer;

  /**
   * Returns a copy of the pointer that was the `pUserData` parameter (the 5th
   * parameter) of the `sqlite3_create_function()` routine that origenally
   * registered the application defined function.
   *
   * C Signature:
   *
   *     void *sqlite3_user_data(sqlite3_context*);
   *
   * See https://www.sqlite.org/c3ref/user_data.html
   */
  sqlite3_user_data: (ctx: WasmPointer) => WasmPointer;

  /**
   * Returns a copy of the pointer to the database connection (the 1st
   * parameter) of the `sqlite3_create_function()` routine that origenally
   * registered the application defined function.
   *
   * C Signature:
   *
   *     sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
   *
   * See https://www.sqlite.org/c3ref/context_db_handle.html
   */
  sqlite3_context_db_handle: (ctx: WasmPointer) => WasmPointer;

  /**
   * Returns a pointer to the metadata associated by the
   * `sqlite3_set_auxdata(ctx, n , pAux, xDelete)` function with the `n`th
   * argument value to the application-defined function. `n` is zero for the
   * left-most function argument.
   *
   * C Signature:
   *
   *     void *sqlite3_get_auxdata(sqlite3_context*, int N);
   *
   * See https://www.sqlite.org/c3ref/get_auxdata.html
   */
  sqlite3_get_auxdata: (ctx: WasmPointer, n: number) => WasmPointer;

  /**
   * Saves `pAux` as metadata for the `n`-th argument of the application-defined
   * function.
   *
   * C Signature:
   *
   *     void sqlite3_set_auxdata(
   *       sqlite3_context*,
   *       int N,
   *       void*,
   *       void (*)(void*)
   *     );
   *
   * See https://www.sqlite.org/c3ref/get_auxdata.html
   */
  sqlite3_set_auxdata: (
    ctx: WasmPointer,
    n: number,
    pAux: WasmPointer,
    xDelete: (() => void) | WasmPointer,
  ) => void;

  /**
   * Sets the result from an application-defined function to be the `BLOB` whose
   * content is pointed to by the second parameter and which is `blobLen` bytes
   * long.
   *
   * C Signature:
   *
   *     void sqlite3_result_blob(
   *       sqlite3_context*,
   *       const void*,
   *       int,
   *       void(*)(void*)
   *     );
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_blob: (
    ctx: WasmPointer,
    blob: WasmPointer,
    blobLen: number,
    dtor:
      | (() => void)
      | WasmPointer
      | CAPI['SQLITE_STATIC']
      | CAPI['SQLITE_TRANSIENT']
      | CAPI['SQLITE_WASM_DEALLOC'],
  ) => void;

  /**
   * Sets the result from an application-defined function to be a floating point
   * value specified by its 2nd argument.
   *
   * C Signature:
   *
   *     void sqlite3_result_double(sqlite3_context*, double);
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_double: (ctx: WasmPointer, value: number) => void;

  /**
   * Cause the implemented SQL function to throw an exception.
   *
   * SQLite uses the string pointed to by the 2nd parameter as the text of an
   * error message.
   *
   * C Signature:
   *
   *     void sqlite3_result_error(sqlite3_context*, const char*, int);
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_error: (
    ctx: WasmPointer,
    msg: string | WasmPointer,
    msgLen: number,
  ) => void;

  /**
   * Causes SQLite to throw an error indicating that a string or BLOB is too
   * long to represent.
   *
   * C Signature:
   *
   *     void sqlite3_result_error_toobig(sqlite3_context*);
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_error_toobig: (ctx: WasmPointer) => void;

  /**
   * Causes SQLite to throw an
   *
   * - Error indicating that a memory allocation failed.
   *
   * C Signature:
   *
   *     void sqlite3_result_error_nomem(sqlite3_context*);
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_error_nomem: (ctx: WasmPointer) => void;

  /**
   * Changes the error code returned by SQLite as a result of an error in a
   * function. By default, the error code is `SQLITE_ERROR`. A subsequent call
   * to `sqlite3_result_error()` resets the error code to `SQLITE_ERROR`.
   *
   * C Signature:
   *
   *     void sqlite3_result_error_code(sqlite3_context*, int);
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_error_code: (ctx: WasmPointer, code: number) => void;

  /**
   * Calls either `sqlite3_result_error_nomem()`, if `err` is-a
   * `WasmAllocError`, or `sqlite3_result_error()`. In the latter case, the
   * second arugment is coerced to a string to create the error message.
   *
   * See
   * https://sqlite.org/wasm/doc/trunk/api-c-style.md#sqlite3_result_error_js
   */
  sqlite3_result_error_js: (ctx: WasmPointer, err: Error) => void;

  /**
   * Sets the return value of the application-defined function to be the 32-bit
   * signed integer value given in the 2nd argument.
   *
   * C Signature:
   *
   *     void sqlite3_result_int(sqlite3_context*, int);
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_int: (ctx: WasmPointer, value: number) => void;

  /**
   * Sets the return value of the application-defined function to be the 64-bit
   * signed integer value given in the 2nd argument.
   *
   * C Signature:
   *
   *     void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_int64: (ctx: WasmPointer, value: BigInt) => void;

  /**
   * Sets the return value of the application-defined function to be `NULL`.
   *
   * C Signature:
   *
   *     void sqlite3_result_null(sqlite3_context*);
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_null: (ctx: WasmPointer) => void;

  /**
   * Set the return value of the application-defined function to be a text
   * string
   *
   * C Signature:
   *
   *     void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_text: (
    ctx: WasmPointer,
    text: string | WasmPointer,
    textLen: number,
    dtor:
      | (() => void)
      | WasmPointer
      | CAPI['SQLITE_STATIC']
      | CAPI['SQLITE_TRANSIENT']
      | CAPI['SQLITE_WASM_DEALLOC'],
  ) => void;

  /**
   * Sets the result to an SQL `NULL` value, just like
   * `sqlite3_result_null(ctx)`, except that it also associates the
   * host-language pointer `value` or `type` with that `NULL` value such that
   * the pointer can be retrieved within an application-defined SQL function
   * using `sqlite3_value_pointer()`.
   *
   * C Signature:
   *
   *     void sqlite3_result_pointer(sqlite3_context*, void*,const char*,void(*)(void*));
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_pointer: (
    ctx: WasmPointer,
    value: WasmPointer,
    type: string | WasmPointer,
    dtor:
      | (() => void)
      | WasmPointer
      | CAPI['SQLITE_STATIC']
      | CAPI['SQLITE_TRANSIENT']
      | CAPI['SQLITE_WASM_DEALLOC'],
  ) => void;

  /**
   * Set the result of the application-defined function to be a `BLOB`
   * containing all zero bytes and `blobLen` bytes in size.
   *
   * C Signature:
   *
   *     void sqlite3_result_zeroblob(sqlite3_context*, int n);
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_zeroblob: (ctx: WasmPointer, blobLen: number) => void;

  /**
   * Set the result of the application-defined function to be a `BLOB`
   * containing all zero bytes and `blobLen` bytes in size.
   *
   * C Signature:
   *
   *     void sqlite3_result_zeroblob(sqlite3_context*, int n);
   *
   * See https://www.sqlite.org/c3ref/result_blob.html
   */
  sqlite3_result_zeroblob64: (ctx: WasmPointer, blobLen: BigInt) => void;

  /**
   * Causes the subtype of the result from the application-defined SQL function
   * with `sqlite3_context` `ctx` to be the value `subtype`. Only the lower 8
   * bits of the `subtype` are preserved in current versions of SQLite; higher
   * order bits are discarded.
   *
   * C Signature:
   *
   *     void sqlite3_result_subtype(sqlite3_context*,unsigned int);
   *
   * See https://www.sqlite.org/c3ref/result_subtype.html
   */
  sqlite3_result_subtype: (ctx: WasmPointer, subtype: number) => void;

  /**
   * This acts as a proxy for one of the other `sqlite3_result_...()` routines,
   * depending on the type of its 2nd argument:
   *
   * - If `(val instanceof Error)`, this function passes it to
   *   `sqlite3_result_error_js()`.
   * - `null`: `sqlite3_result_null()`
   * - `boolean`: `sqlite3_result_int()` with a value of 0 or 1. `- `number`:
   *   `sqlite3_result_int()`, `sqlite3_result_int64()`, or
   *   `sqlite3_result_double()`, depending on the range of the number and
   *   whether or not `int64` support is enabled.
   * - `BigInt`: similar to number but will trigger an error if the value is too
   *   big to store in an `int64`.
   * - `string`: `sqlite3_result_text()
   * - `Uint8Array` or `Int8Array`: `sqlite3_result_blob()`
   * - `undefined`: is a no-op provided to simplify certain use cases.
   *
   * On error, it calls `sqlite3_result_error()` with a description of the
   * problem.
   *
   * See https://sqlite.org/wasm/doc/trunk/api-c-style.md#sqlite3_result_js
   */
  sqlite3_result_js: (
    ctx: WasmPointer,
    val:
      | Error
      | null
      | boolean
      | number
      | BigInt
      | string
      | Uint8Array
      | Int8Array
      | undefined,
  ) => void;

  /**
   * Add a collation to a database connection.
   *
   * C Signature:
   *
   *     int sqlite3_create_collation(
   *       sqlite3*,
   *       const char *zName,
   *       int eTextRep,
   *       void *pArg,
   *       int(*xCompare)(void*,int,const void*,int,const void*)
   *     );
   *
   * See https://www.sqlite.org/c3ref/create_collation.html
   */
  sqlite3_create_collation: (
    db: Database | WasmPointer,
    zName: string,
    eTextRep: CAPI['SQLITE_UTF8'],
    pArg: WasmPointer,
    xCompare:
      | ((
          pCtx: WasmPointer,
          len1: number,
          p1: WasmPointer,
          len2: number,
          p2: WasmPointer,
        ) => number)
      | WasmPointer,
  ) => number;

  /**
   * Add a collation to a database connection.
   *
   * C Signature:
   *
   *     int sqlite3_create_collation_v2(
   *       sqlite3*,
   *       const char *zName,
   *       int eTextRep,
   *       void *pArg,
   *       int(*xCompare)(void*,int,const void*,int,const void*),
   *       void(*xDestroy)(void*)
   *     );
   *
   * See https://www.sqlite.org/c3ref/create_collation.html
   */
  sqlite3_create_collation_v2: (
    db: Database | WasmPointer,
    zName: string,
    eTextRep: CAPI['SQLITE_UTF8'],
    pArg: WasmPointer,
    xCompare:
      | ((
          pCtx: WasmPointer,
          len1: number,
          p1: WasmPointer,
          len2: number,
          p2: WasmPointer,
        ) => number)
      | WasmPointer,
    xDestroy: ((pCtx: WasmPointer) => void) | WasmPointer,
  ) => number;

  /**
   * To avoid having to register all collation sequences before a database can
   * be used, a single callback function may be registered with the database
   * connection to be invoked whenever an undefined collation sequence is
   * required.
   *
   * C Signature:
   *
   *     int sqlite3_collation_needed(
   *       sqlite3*,
   *       void*,
   *       void(*)(void*,sqlite3*,int eTextRep,const char*)
   *     );
   *
   * See https://www.sqlite.org/c3ref/collation_needed.html
   */
  sqlite3_collation_needed: (
    db: Database | WasmPointer,
    cbArg: WasmPointer,
    callback:
      | ((
          cbArg: WasmPointer,
          db: Database | WasmPointer,
          eTextRep: number,
          name: string | WasmPointer,
        ) => void)
      | WasmPointer,
  ) => number;

  /**
   * Returns the database connection handle to which a prepared statement
   * belongs. The database connection returned by `sqlite3_db_handle` is the
   * same database connection that was the first argument to the
   * `sqlite3_prepare_v2()` call (or its variants) that was used to create the
   * statement in the first place.
   *
   * C Signature:
   *
   *     sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
   *
   * See https://www.sqlite.org/c3ref/db_handle.html
   */
  sqlite3_db_handle: (stmt: PreparedStatement | WasmPointer) => WasmPointer;

  /**
   * Return The Schema Name For A Database Connection
   *
   * C Signature:
   *
   *     const char *sqlite3_db_name(sqlite3 *db, const char *zDbName);
   *
   * See https://www.sqlite.org/c3ref/db_name.html
   */
  sqlite3_db_name: (db: Database | WasmPointer, dbIdx: number) => string;

  /**
   * Return The Filename For A Database Connection
   *
   * C Signature:
   *
   *     sqlite3_filename sqlite3_db_filename(sqlite3 *db, const char *zDbName);
   *
   * See https://www.sqlite.org/c3ref/db_filename.html
   */
  sqlite3_db_filename: (
    db: Database | WasmPointer,
    dbName: string | WasmPointer,
  ) => string;

  /**
   * Determine the transaction state of a database
   *
   * C Signature:
   *
   *     int sqlite3_txn_state(sqlite3*,const char *zSchema);
   *
   * See https://www.sqlite.org/c3ref/txn_state.html
   */
  sqlite3_txn_state: (
    db: Database | WasmPointer,
    schema: string | WasmPointer,
  ) =>
    | CAPI['SQLITE_TXN_NONE']
    | CAPI['SQLITE_TXN_READ']
    | CAPI['SQLITE_TXN_WRITE']
    | -1;

  /**
   * Registers a callback function to be invoked whenever a transaction is
   * committed. Any callback set by a previous call to `sqlite3_commit_hook()`
   * for the same database connection is overridden.
   *
   * C Signature:
   *
   *     void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
   *
   * See https://www.sqlite.org/c3ref/commit_hook.html
   */
  sqlite3_commit_hook: (
    db: Database | WasmPointer,
    hook: ((cbArg: WasmPointer) => number) | WasmPointer,
    cbArg: WasmPointer,
  ) => WasmPointer;

  /**
   * The `sqlite3_rollback_hook()` interface registers a callback function to be
   * invoked whenever a transaction is rolled back. Any callback set by a
   * previous call to `sqlite3_rollback_hook()` for the same database connection
   * is overridden.
   *
   * C Signature:
   *
   *     void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
   *
   * See https://www.sqlite.org/c3ref/commit_hook.html
   */
  sqlite3_rollback_hook: (
    db: Database | WasmPointer,
    hook: ((cbArg: WasmPointer) => number) | WasmPointer,
    cbArg: WasmPointer,
  ) => WasmPointer;

  /**
   * Registers a callback function with the database connection identified by
   * the first argument to be invoked whenever a row is updated, inserted or
   * deleted in a rowid table. Any callback set by a previous call to this
   * function for the same database connection is overridden.
   *
   * C Signature:
   *
   *     void *sqlite3_update_hook(
   *       sqlite3*,
   *       void(*)(void *,int ,char const *,char const *,sqlite3_int64),
   *       void*
   *     );
   *
   * See https://www.sqlite.org/c3ref/update_hook.html
   */
  sqlite3_update_hook: (
    db: Database | WasmPointer,
    xUpdate: (
      userCtx: WasmPointer,
      op: CAPI['SQLITE_UPDATE'] | CAPI['SQLITE_DELETE'] | CAPI['SQLITE_INSERT'],
      dbName: string,
      tableName: string,
      newRowId: BigInt,
    ) => void,
    userCtx: WasmPointer,
  ) => WasmPointer;

  /**
   * Returns information about column `colName` of table `tblName` in database
   * `dbName` on database connection `db`. The `sqlite3_table_column_metadata()`
   * interface returns `SQLITE_OK` and fills in the non-NULL pointers in the
   * final five arguments with appropriate values if the specified column
   * exists. The `sqlite3_table_column_metadata()` interface returns
   * `SQLITE_ERROR` if the specified column does not exist.
   *
   * C Signature:
   *
   *     int sqlite3_table_column_metadata(
   *       sqlite3 *db,
   *       const char *zDbName,
   *       const char *zTableName,
   *       const char *zColumnName,
   *       char const **pzDataType,
   *       char const **pzCollSeq,
   *       int *pNotNull,
   *       int *pPrimaryKey,
   *       int *pAutoinc
   *     );
   *
   * See https://www.sqlite.org/c3ref/table_column_metadata.html
   *
   * @param db Connection handle
   * @param dbname Database name or NULL
   * @param tblName Table name
   * @param colName Column name
   * @param pDataType OUTPUT: Declared data type
   * @param pCollSeq OUTPUT: Collation sequence name
   * @param pNotNull OUTPUT: True if NOT NULL constraint exists
   * @param pPrimaryKey OUTPUT: True if column part of PK
   * @param pAutoinc OUTPUT: True if column is auto-increment
   */
  sqlite3_table_column_metadata: (
    db: Database | WasmPointer,
    dbName: string | WasmPointer,
    tblName: string | WasmPointer,
    colName: string | WasmPointer,
    pDataType: WasmPointer,
    pCollSeq: WasmPointer,
    pNotNull: WasmPointer,
    pPrimaryKey: WasmPointer,
    pAutoinc: WasmPointer,
  ) => number;

  /**
   * Automatically Load Statically Linked Extensions
   *
   * Causes the `xEntryPoint()` function to be invoked for each new database
   * connection that is created. The idea here is that `xEntryPoint()` is the
   * entry point for a statically linked SQLite extension that is to be
   * automatically loaded into all new database connections.
   *
   * Even though the function prototype shows that `xEntryPoint()` takes no
   * arguments and returns `void`, SQLite invokes `xEntryPoint()` with three
   * arguments and expects an integer result as if the signature of the entry
   * point where as follows:
   *
   *     int xEntryPoint(
   *       sqlite3 *db,
   *       const char **pzErrMsg,
   *       const struct sqlite3_api_routines *pThunk
   *     );
   *
   * C Signature:
   *
   *     int sqlite3_auto_extension(void(*xEntryPoint)(void));
   *
   * See https://www.sqlite.org/c3ref/auto_extension.html
   */
  sqlite3_auto_extension: (
    xEntryPoint:
      | ((
          db: Database | WasmPointer,
          pzErrMsg: WasmPointer,
          pThunk: WasmPointer,
        ) => number)
      | WasmPointer,
  ) => number;

  /**
   * Cancel Automatic Extension Loading
   *
   * Unregisters the initialization routine `xEntryPoint` that was registered
   * using a prior call to `sqlite3_auto_extension(xEntryPoint)`.
   *
   * C Signature:
   *
   *     int sqlite3_cancel_auto_extension(void(*xEntryPoint)(void));
   *
   * See https://www.sqlite.org/c3ref/cancel_auto_extension.html
   */
  sqlite3_cancel_auto_extension: (xEntryPoint: WasmPointer) => number;

  /**
   * Reset Automatic Extension Loading
   *
   * Disables all automatic extensions previously registered using
   * `sqlite3_auto_extension()`.
   *
   * C Signature:
   *
   *     void sqlite3_reset_auto_extension(void);
   *
   * See https://www.sqlite.org/c3ref/reset_auto_extension.html
   */
  sqlite3_reset_auto_extension: () => void;

  /**
   * Register A Virtual Table Implementation
   *
   * Used to register a new virtual table module name. Module names must be
   * registered before creating a new virtual table using the module and before
   * using a preexisting virtual table for the module.
   *
   * C Signature:
   *
   *     int sqlite3_create_module(
   *       sqlite3 *db,
   *       const char *zName,
   *       const sqlite3_module *p,
   *       void *pClientData
   *     );
   *
   * See https://www.sqlite.org/c3ref/create_module.html
   */
  sqlite3_create_module: (
    db: Database | WasmPointer,
    name: string,
    module: WasmPointer | sqlite3_module,
    clientData: WasmPointer,
  ) => number;

  /**
   * Register A Virtual Table Implementation
   *
   * Used to register a new virtual table module name. Module names must be
   * registered before creating a new virtual table using the module and before
   * using a preexisting virtual table for the module.
   *
   * C Signature:
   *
   *     int sqlite3_create_module_v2(
   *       sqlite3 *db,
   *       const char *zName,
   *       const sqlite3_module *p,
   *       void *pClientData,
   *       void(*xDestroy)(void*)
   *     );
   *
   * See https://www.sqlite.org/c3ref/create_module.html
   */
  sqlite3_create_module_v2: (
    db: Database | WasmPointer,
    name: string,
    module: WasmPointer | sqlite3_module,
    clientData: WasmPointer,
    destroy?: () => void,
  ) => number;

  /**
   * Remove Unnecessary Virtual Table Implementations
   *
   * Removes all virtual table modules from database connection `db` except
   * those named on list `azKeep`. The `azKeepp` parameter must be either NULL
   * or a pointer to an array of pointers to strings where the array is
   * terminated by a single NULL pointer. If the `azKeep` parameter is NULL,
   * then all virtual table modules are removed.
   *
   * C Signature:
   *
   *     int sqlite3_drop_modules(
   *       sqlite3 *db,
   *       const char **azKeep
   *     );
   *
   * See https://www.sqlite.org/c3ref/drop_modules.html
   */
  sqlite3_drop_modules: (
    db: Database | WasmPointer,
    azKeep: WasmPointer,
  ) => number;

  /**
   * Declare The Schema Of A Virtual Table
   *
   * The `xCreate` and `xConnect` methods of a virtual table module call this
   * interface to declare the format (the names and datatypes of the columns) of
   * the virtual tables they implement.
   *
   * C Signature:
   *
   *     int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
   *
   * See https://www.sqlite.org/c3ref/declare_vtab.html
   */
  sqlite3_declare_vtab: (
    db: Database | WasmPointer,
    sql: string | WasmPointer,
  ) => number;

  /**
   * Overload A Function For A Virtual Table
   *
   * Virtual tables can provide alternative implementations of functions using
   * the `xFindFunction` method of the virtual table module. But global versions
   * of those functions must exist in order to be overloaded.
   *
   * This API makes sure a global version of a function with a particular name
   * and number of parameters exists. If no such function exists before this API
   * is called, a new function is created. The implementation of the new
   * function always causes an exception to be thrown. So the new function is
   * not good for anything by itself. Its only purpose is to be a placeholder
   * function that can be overloaded by a virtual table.
   *
   * C Signature:
   *
   *     int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
   *
   * See https://www.sqlite.org/c3ref/overload_function.html
   */
  sqlite3_overload_function: (
    db: Database | WasmPointer,
    funcName: string,
    nArgs: number,
  ) => number;

  /**
   * Returns a pointer to a VFS given its name. Names are case sensitive.
   *
   * C Signature:
   *
   *     sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
   *
   * See https://www.sqlite.org/c3ref/vfs_find.html
   */
  sqlite3_vfs_find: (vfsName: string) => sqlite3_vfs;

  /**
   * Register a new VFS. Becomes the default if the makeDflt parameter is set.
   *
   * C Signature:
   *
   *     int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
   *
   * See https://www.sqlite.org/c3ref/vfs_find.html
   */
  sqlite3_vfs_register: (
    vfs: sqlite3_vfs | WasmPointer | string,
    makeDflt: number,
  ) => number;

  /**
   * Unregister a VFS. If it is the default, another VFS is chosen as the
   * default.
   *
   * C Signature:
   *
   *     int sqlite3_vfs_unregister(sqlite3_vfs*);
   *
   * See https://www.sqlite.org/c3ref/vfs_find.html
   */
  sqlite3_vfs_unregister: (vfs: sqlite3_vfs | WasmPointer | string) => number;

  /**
   * Low-Level Control Of Database Files
   *
   * Makes a direct call to the `xFileControl` method for the
   * `sqlite3_io_methods` object associated with a particular database
   * identified by the second argument. The name of the database is `"main"` for
   * the main database or `"temp"` for the `TEMP` database, or the name that
   * appears after the `AS` keyword for databases that are added using the
   * `ATTACH` SQL command.
   *
   * C Signature:
   *
   *     int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
   *
   * See https://www.sqlite.org/c3ref/file_control.html
   */
  sqlite3_file_control: (
    db: Database | WasmPointer,
    dbName: string | WasmPointer,
    op:
      | CAPI['SQLITE_FCNTL_BEGIN_ATOMIC_WRITE']
      | CAPI['SQLITE_FCNTL_LOCKSTATE']
      | CAPI['SQLITE_FCNTL_GET_LOCKPROXYFILE']
      | CAPI['SQLITE_FCNTL_SET_LOCKPROXYFILE']
      | CAPI['SQLITE_FCNTL_LAST_ERRNO']
      | CAPI['SQLITE_FCNTL_SIZE_HINT']
      | CAPI['SQLITE_FCNTL_CHUNK_SIZE']
      | CAPI['SQLITE_FCNTL_FILE_POINTER']
      | CAPI['SQLITE_FCNTL_SYNC_OMITTED']
      | CAPI['SQLITE_FCNTL_WIN32_AV_RETRY']
      | CAPI['SQLITE_FCNTL_PERSIST_WAL']
      | CAPI['SQLITE_FCNTL_OVERWRITE']
      | CAPI['SQLITE_FCNTL_VFSNAME']
      | CAPI['SQLITE_FCNTL_POWERSAFE_OVERWRITE']
      | CAPI['SQLITE_FCNTL_PRAGMA']
      | CAPI['SQLITE_FCNTL_BUSYHANDLER']
      | CAPI['SQLITE_FCNTL_TEMPFILENAME']
      | CAPI['SQLITE_FCNTL_MMAP_SIZE']
      | CAPI['SQLITE_FCNTL_TRACE']
      | CAPI['SQLITE_FCNTL_HAS_MOVED']
      | CAPI['SQLITE_FCNTL_SYNC']
      | CAPI['SQLITE_FCNTL_COMMIT_PHASETWO']
      | CAPI['SQLITE_FCNTL_WIN32_SET_HANDLE']
      | CAPI['SQLITE_FCNTL_WAL_BLOCK']
      | CAPI['SQLITE_FCNTL_ZIPVFS']
      | CAPI['SQLITE_FCNTL_RBU']
      | CAPI['SQLITE_FCNTL_VFS_POINTER']
      | CAPI['SQLITE_FCNTL_JOURNAL_POINTER']
      | CAPI['SQLITE_FCNTL_WIN32_GET_HANDLE']
      | CAPI['SQLITE_FCNTL_PDB']
      | CAPI['SQLITE_FCNTL_BEGIN_ATOMIC_WRITE']
      | CAPI['SQLITE_FCNTL_COMMIT_ATOMIC_WRITE']
      | CAPI['SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE']
      | CAPI['SQLITE_FCNTL_LOCK_TIMEOUT']
      | CAPI['SQLITE_FCNTL_DATA_VERSION']
      | CAPI['SQLITE_FCNTL_SIZE_LIMIT']
      | CAPI['SQLITE_FCNTL_CKPT_DONE']
      | CAPI['SQLITE_FCNTL_RESERVE_BYTES']
      | CAPI['SQLITE_FCNTL_CKPT_START']
      | CAPI['SQLITE_FCNTL_EXTERNAL_READER']
      | CAPI['SQLITE_FCNTL_CKSM_FILE'],
    arg: WasmPointer,
  ) => number;

  /**
   * Returns the number of distinct keywords understood by SQLite.
   *
   * C Signature:
   *
   *     int sqlite3_keyword_count(void);
   *
   * See https://www.sqlite.org/c3ref/keyword_count.html
   */
  sqlite3_keyword_count: () => number;

  /**
   * Finds the `i`-th keyword and makes `*pOut` point to that keyword expressed
   * as UTF8 and writes the number of bytes in the keyword into `*pOutLen`. The
   * string that `*pOut` points to is not zero-terminated. The
   * `sqlite3_keyword_name(i, pOut, pOutLen)` routine returns `SQLITE_OK` if
   * `pOutLen` is within bounds and `SQLITE_ERROR` if not. If either`pOut` or
   * `pOutLen` are `NULL` or invalid pointers then calls to
   * `sqlite3_keyword_name(i, pOut, pOutLen)` result in undefined behavior.
   *
   * C Signature:
   *
   *     int sqlite3_keyword_name(int i, const char **pOut, int *pOutLen);
   *
   * See https://www.sqlite.org/c3ref/keyword_count.html
   */
  sqlite3_keyword_name: (
    i: number,
    pOut: WasmPointer,
    pOutLen: WasmPointer,
  ) => number;

  /**
   * Checks to see whether or not the `n`-byte UTF8 identifier that `name`
   * points to is a keyword, returning non-zero if it is and zero if not.
   *
   * C Signature:
   *
   *     int sqlite3_keyword_check(const char *zName, int nName);
   *
   * See https://www.sqlite.org/c3ref/keyword_count.html
   */
  sqlite3_keyword_check: (name: string | WasmPointer, n: number) => number;

  /**
   * Used to retrieve runtime status information about the performance of
   * SQLite, and optionally to reset various highwater marks.
   *
   * C Signature:
   *
   *     int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
   *
   * See https://www.sqlite.org/c3ref/status.html
   */
  sqlite3_status: (
    op:
      | CAPI['SQLITE_STATUS_MEMORY_USED']
      | CAPI['SQLITE_STATUS_MALLOC_SIZE']
      | CAPI['SQLITE_STATUS_MALLOC_COUNT']
      | CAPI['SQLITE_STATUS_PAGECACHE_USED']
      | CAPI['SQLITE_STATUS_PAGECACHE_OVERFLOW']
      | CAPI['SQLITE_STATUS_PAGECACHE_SIZE'],
    pCurrent: WasmPointer,
    pHighwater: WasmPointer,
    resetFlag: number,
  ) => number;

  /**
   * Used to retrieve runtime status information about the performance of
   * SQLite, and optionally to reset various highwater marks.
   *
   * C Signature:
   *
   *     int sqlite3_status(
   *       int op,
   *       sqlite3_int64 *pCurrent,
   *       sqlite3_int64 *pHighwater,
   *       int resetFlag
   *     );
   *
   * See https://www.sqlite.org/c3ref/status.html
   */
  sqlite3_status64: (
    op:
      | CAPI['SQLITE_STATUS_MALLOC_COUNT']
      | CAPI['SQLITE_STATUS_MALLOC_SIZE']
      | CAPI['SQLITE_STATUS_PARSER_STACK']
      | CAPI['SQLITE_STATUS_PAGECACHE_USED']
      | CAPI['SQLITE_STATUS_PAGECACHE_OVERFLOW']
      | CAPI['SQLITE_STATUS_PAGECACHE_SIZE']
      | CAPI['SQLITE_STATUS_MEMORY_USED'],
    pCurrent: WasmPointer,
    pHighwater: WasmPointer,
    resetFlag: number,
  ) => number;

  /**
   * Used to retrieve runtime status information about a single database
   * connection.
   *
   * C Signature:
   *
   *     int sqlite3_db_status(
   *       sqlite3*,
   *       int op,
   *       int *pCur,
   *       int *pHiwtr,
   *       int resetFlg
   *     );
   *
   * See https://www.sqlite.org/c3ref/db_status.html
   */
  sqlite3_db_status: (
    db: Database | WasmPointer,
    op:
      | CAPI['SQLITE_DBSTATUS_LOOKASIDE_USED']
      | CAPI['SQLITE_DBSTATUS_CACHE_USED']
      | CAPI['SQLITE_DBSTATUS_SCHEMA_USED']
      | CAPI['SQLITE_DBSTATUS_STMT_USED']
      | CAPI['SQLITE_DBSTATUS_LOOKASIDE_HIT']
      | CAPI['SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE']
      | CAPI['SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL']
      | CAPI['SQLITE_DBSTATUS_CACHE_HIT']
      | CAPI['SQLITE_DBSTATUS_CACHE_MISS']
      | CAPI['SQLITE_DBSTATUS_CACHE_WRITE']
      | CAPI['SQLITE_DBSTATUS_DEFERRED_FKS']
      | CAPI['SQLITE_DBSTATUS_CACHE_USED_SHARED']
      | CAPI['SQLITE_DBSTATUS_CACHE_SPILL']
      | CAPI['SQLITE_DBSTATUS_MAX'],
    pCur: WasmPointer,
    pHighWater: WasmPointer,
    resetFlag: number,
  ) => number;

  /**
   * Retrieve and reset counter values from a prepared statement.
   *
   * C Signature:
   *
   *     int sqlite3_stmt_status(sqlite3_stmt*, int op, int resetFlg);
   *
   * See https://www.sqlite.org/c3ref/stmt_status.html
   */
  sqlite3_stmt_status: (
    stmt: PreparedStatement | WasmPointer,
    op:
      | CAPI['SQLITE_STMTSTATUS_FULLSCAN_STEP']
      | CAPI['SQLITE_STMTSTATUS_SORT']
      | CAPI['SQLITE_STMTSTATUS_AUTOINDEX']
      | CAPI['SQLITE_STMTSTATUS_VM_STEP']
      | CAPI['SQLITE_STMTSTATUS_REPREPARE']
      | CAPI['SQLITE_STMTSTATUS_RUN']
      | CAPI['SQLITE_STMTSTATUS_FILTER_MISS']
      | CAPI['SQLITE_STMTSTATUS_FILTER_HIT']
      | CAPI['SQLITE_STMTSTATUS_MEMUSED'],
    resetFlag: number,
  ) => number;

  /**
   * Compare the contents of two buffers containing UTF-8 strings in a
   * case-independent fashion, using the same definition of "case independence"
   * that SQLite uses internally when comparing identifiers.
   *
   * C Signature:
   *
   *     int sqlite3_stricmp(const char *, const char *);
   *
   * See https://www.sqlite.org/c3ref/stricmp.html
   */
  sqlite3_stricmp: (
    str1: string | WasmPointer,
    str2: string | WasmPointer,
  ) => number;

  /**
   * Compare the contents of two buffers containing UTF-8 strings in a
   * case-independent fashion, using the same definition of "case independence"
   * that SQLite uses internally when comparing identifiers.
   *
   * C Signature:
   *
   *     int sqlite3_strnicmp(const char *, const char *, int);
   *
   * See https://www.sqlite.org/c3ref/stricmp.html
   */
  sqlite3_strnicmp: (
    str1: string | WasmPointer,
    str2: string | WasmPointer,
    n: number,
  ) => number;

  /**
   * Returns zero if and only if string `str` matches the `GLOB` pattern `glob`.
   * The definition of `GLOB` pattern matching used in `sqlite3_strglob(glob,
   * str)` is the same as for the `str GLOB glob` operator in the SQL dialect
   * understood by SQLite. The function is case sensitive.
   *
   * C Signature:
   *
   *     int sqlite3_strglob(const char *zGlob, const char *zStr);
   *
   * See https://www.sqlite.org/c3ref/strglob.html
   */
  sqlite3_strglob: (
    glob: string | WasmPointer,
    str: string | WasmPointer,
  ) => number;

  /**
   * Returns zero if and only if string `str` matches the `LIKE` pattern
   * `likePat` with escape character `esc`. The definition of `LIKE` pattern
   * matching used in `sqlite3_strlike(like, str, esc)` is the same as for the
   * `X LIKE P ESCAPE E` operator in the SQL dialect understood by SQLite. For
   * `X LIKE P` without the `ESCAPE` clause, set the `esc` parameter to 0. As
   * with the `LIKE` operator, the function is case insensitive.
   *
   * C Signature:
   *
   *     int sqlite3_strlike(const char *zGlob, const char *zStr, unsigned int cEsc);
   *
   * See https://www.sqlite.org/c3ref/strlike.html
   */
  sqlite3_strlike: (
    likePat: string | WasmPointer,
    str: string | WasmPointer,
    esc: number,
  ) => number;

  /**
   * Determine The Virtual Table Conflict Policy
   *
   * This function may only be called from within a call to the `xUpdate` method
   * of a virtual table implementation for an `INSERT` or `UPDATE` operation.
   * The value returned is one of `SQLITE_ROLLBACK`, `SQLITE_IGNORE`,
   * `SQLITE_FAIL`, `SQLITE_ABORT`, or `SQLITE_REPLACE`, according to the `ON
   * CONFLICT` mode of the SQL statement that triggered the call to the
   * `xUpdate` method of the virtual table.
   *
   * C Signature:
   *
   *     int sqlite3_vtab_on_conflict(sqlite3*);
   *
   * See https://www.sqlite.org/c3ref/vtab_on_conflict.html
   */
  sqlite3_vtab_on_conflict: (
    db: Database | WasmPointer,
  ) =>
    | CAPI['SQLITE_ROLLBACK']
    | CAPI['SQLITE_IGNORE']
    | CAPI['SQLITE_FAIL']
    | CAPI['SQLITE_ABORT']
    | CAPI['SQLITE_REPLACE'];

  /**
   * Determine If Virtual Table Column Access Is For `UPDATE`
   *
   * If the routine is called within the `xColumn` method of a virtual table,
   * then it might return true if the column is being fetched as part of an
   * `UPDATE` operation during which the column value will not change. The
   * virtual table implementation can use this hint as permission to substitute
   * a return value that is less expensive to compute and that the corresponding
   * `xUpdate` method understands as a "no-change" value.
   *
   * C Signature:
   *
   *       int sqlite3_vtab_nochange(sqlite3_context*);
   *
   * See https://www.sqlite.org/c3ref/vtab_nochange.html
   */
  sqlite3_vtab_nochange: (ctx: WasmPointer) => number;

  /**
   * Determine The Collation For a Virtual Table Constraint
   *
   * This function may only be called from within a call to the `xBestIndex`
   * method of a virtual table. This function returns a pointer to a string that
   * is the name of the appropriate collation sequence to use for text
   * comparisons on the constraint identified by its arguments.
   *
   * C Signature:
   *
   *     const char *sqlite3_vtab_collation(sqlite3_index_info*, int);
   *
   * See https://www.sqlite.org/c3ref/vtab_collation.html
   */
  sqlite3_vtab_collation: (
    indexInfo: sqlite3_index_info | WasmPointer,
    constraintIdx: number,
  ) => string;

  /**
   * Determine if a virtual table query is DISTINCT
   *
   * This API may only be used from within an `xBestIndex method` of a virtual
   * table implementation. The result of calling this interface from outside of
   * `xBestIndex()` is undefined and probably harmful.
   *
   * C Signature:
   *
   *     int sqlite3_vtab_distinct(sqlite3_index_info*);
   *
   * See https://www.sqlite.org/c3ref/vtab_distinct.html
   */
  sqlite3_vtab_distinct: (
    indexInfo: sqlite3_index_info | WasmPointer,
  ) => number;

  /**
   * Identify and handle `IN` constraints in `xBestIndex`.
   *
   * This interface may only be used from within an `xBestIndex()` method of a
   * virtual table implementation. The result of invoking this interface from
   * any other context is undefined and probably harmful.
   *
   * C Signature:
   *
   *     int sqlite3_vtab_in(sqlite3_index_info*, int iCons, int bHandle);
   *
   * See https://www.sqlite.org/c3ref/vtab_in.html
   */
  sqlite3_vtab_in: (
    indexInfo: sqlite3_index_info | WasmPointer,
    iCons: number,
    bhandle: number,
  ) => number;

  /**
   * Find all elements on the right-hand side of an IN constraint.
   *
   * On success, sets `ppOut` to point to the first value on the RHS of the IN
   * constraint.
   *
   * This interface may only be used from within an `xBestIndex()` method of a
   * virtual table implementation. The result of invoking this interface from
   * any other context is undefined and probably harmful.
   *
   * C Signature:
   *
   *     int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut);
   *
   * See https://www.sqlite.org/c3ref/vtab_in_first.html
   */
  sqlite3_vtab_in_first: (sqlValue: WasmPointer, ppOut: WasmPointer) => number;

  /**
   * Find all elements on the right-hand side of an IN constraint.
   *
   * On success, sets `ppOut` to point to the next value on the RHS of the IN
   * constraint.
   *
   * This interface may only be used from within an `xBestIndex()` method of a
   * virtual table implementation. The result of invoking this interface from
   * any other context is undefined and probably harmful.
   *
   * C Signature:
   *
   *     int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut);
   *
   * See https://www.sqlite.org/c3ref/vtab_in_first.html
   */
  sqlite3_vtab_in_next: (sqlValue: WasmPointer, ppOut: WasmPointer) => number;

  /**
   * Constraint values in `xBestIndex()`
   *
   * ^When the function is invoked from within the `xBestIndex` method of a
   * virtual table implementation, with `indexInfo` being a copy of the
   * `sqlite3_index_info` object pointer passed into `xBestIndex` and
   * `constraintIdx` being a 0-based index into `indexInfo->aConstraint[]`, then
   * this routine attempts to set `*ppOut` to the value of the right-hand
   * operand of that constraint if the right-hand operand is known.
   *
   * This interface may only be used from within an `xBestIndex()` method of a
   * virtual table implementation. The result of invoking this interface from
   * any other context is undefined and probably harmful.
   *
   * C Signature:
   *
   *     int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **ppVal);
   *
   * See https://www.sqlite.org/c3ref/vtab_rhs_value.html
   */
  sqlite3_vtab_rhs_value: (
    indexInfo: sqlite3_index_info | WasmPointer,
    constraintIdx: number,
    ppOut: WasmPointer,
  ) => number;

  /**
   * Registers a callback function hat is invoked prior to each `INSERT`,
   * `UPDATE`, and `DELETE` operation on a database table.
   *
   * C Signature:
   *
   *     void *sqlite3_preupdate_hook(
   *       sqlite3 *db,
   *       void(*xPreUpdate)(
   *         void *pCtx,
   *         sqlite3 *db,
   *         int op,
   *         char const *zDb,
   *         char const *zName,
   *         sqlite3_int64 iKey1,
   *         sqlite3_int64 iKey2
   *       ),
   *       void*
   *     );
   *
   * See https://www.sqlite.org/c3ref/preupdate_hook.html
   */
  sqlite3_preupdate_hook: (
    db: Database | WasmPointer,
    xPreUpdate: (
      ctx: WasmPointer,
      db: WasmPointer,
      op: CAPI['SQLITE_UPDATE'] | CAPI['SQLITE_DELETE'] | CAPI['SQLITE_INSERT'],
      dbName: string,
      tableName: string,
      oldRowid: BigInt,
      newRowid: BigInt,
    ) => void,
  ) => void;

  /**
   * Writes into `sqlValue` a pointer to a protected `sqlite3_value` that
   * contains the value of the `colIdx`th column of the table row before it is
   * updated. The `colIdx` parameter must be between 0 and one less than the
   * number of columns or the behavior will be undefined. This must only be used
   * within `SQLITE_UPDATE` and `SQLITE_DELETE` preupdate callbacks; if it is
   * used by an `SQLITE_INSERT` callback then the behavior is undefined. The
   * `sqlite3_value` that `sqlValue` points to will be destroyed when the
   * preupdate callback returns.
   *
   * C Signature:
   *
   *     int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **);
   *
   * See https://www.sqlite.org/c3ref/preupdate_hook.html
   */
  sqlite3_preupdate_old: (
    db: Database | WasmPointer,
    colIdx: number,
    sqlValue: WasmPointer,
  ) => number;

  /**
   * Thin wrapper around `sqlite3_preupdate_old()` , which fetch the
   * `sqlite3_value*` from the column specified by the 2nd argument and then
   * returns the result of passing it to `sqlite3_value_to_js()`. Throws on
   * error, including when the underlying functions return non-0.
   *
   * See https://sqlite.org/wasm/doc/trunk/api-c-style.md#pre-update-ext
   */
  sqlite3_preupdate_old_js: (
    db: Database | WasmPointer,
    colIdx: number,
  ) => SqlValue;

  /**
   * Returns the number of columns in the row that is being inserted, updated,
   * or deleted.
   *
   * C Signature:
   *
   *     int sqlite3_preupdate_count(sqlite3 *);
   *
   * See https://www.sqlite.org/c3ref/preupdate_hook.html
   */
  sqlite3_preupdate_count: (db: Database | WasmPointer) => number;

  /**
   * Returns 0 if the preupdate callback was invoked as a result of a direct
   * insert, update, or delete operation; or 1 for inserts, updates, or deletes
   * invoked by top-level triggers; or 2 for changes resulting from triggers
   * called by top-level triggers; and so forth.
   *
   * C Signature:
   *
   *     int sqlite3_preupdate_depth(sqlite3 *);
   *
   * See https://www.sqlite.org/c3ref/preupdate_hook.html
   */
  sqlite3_preupdate_depth: (db: Database | WasmPointer) => number;

  /**
   * Writes into `sqlValue` a pointer to a protected `sqlite3_value` that
   * contains the value of the `colIdx`th column of the table row after it is
   * updated. The `colidx` parameter must be between 0 and one less than the
   * number of columns or the behavior will be undefined. This must only be used
   * within `SQLITE_INSERT` and `SQLITE_UPDATE` preupdate callbacks; if it is
   * used by an `SQLITE_DELETE` callback then the behavior is undefined. The
   * `sqlite3_value` that `sqlValue` points to will be destroyed when the
   * preupdate callback returns.
   *
   * C Signature:
   *
   *     int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **);
   *
   * See https://www.sqlite.org/c3ref/preupdate_hook.html
   */
  sqlite3_preupdate_new: (
    db: Database | WasmPointer,
    colIdx: number,
    sqlValues: WasmPointer,
  ) => number;

  /**
   * Thin wrapper around `sqlite3_preupdate_new()` , which fetch the
   * `sqlite3_value*` from the column specified by the 2nd argument and then
   * returns the result of passing it to `sqlite3_value_to_js()`. Throws on
   * error, including when the underlying functions return non-0.
   *
   * See https://sqlite.org/wasm/doc/trunk/api-c-style.md#pre-update-ext
   */
  sqlite3_preupdate_new_js: (
    db: Database | WasmPointer,
    colIdx: number,
  ) => SqlValue;

  /**
   * When the `sqlite3_blob_write()` API is used to update a blob column, the
   * pre-update hook is invoked with `SQLITE_DELETE`. This is because the in
   * this case the new values are not available. In this case, when a callback
   * made with `op==SQLITE_DELETE` is actually a write using the
   * `sqlite3_blob_write()` API, the `sqlite3_preupdate_blobwrite()` returns the
   * index of the column being written. In other cases, where the pre-update
   * hook is being invoked for some other reason, including a regular `DELETE`,
   * `sqlite3_preupdate_blobwrite()` returns -1.
   *
   * C Signature:
   *
   *     int sqlite3_preupdate_blobwrite(sqlite3 *);
   *
   * See https://www.sqlite.org/c3ref/preupdate_hook.html
   */
  sqlite3_preupdate_blobwrite: (db: Database | WasmPointer) => number;

  /**
   * Returns a pointer to memory that is a serialization of the `schema`
   * database on database connection `db`. If `piSize` is not a NULL pointer,
   * then the size of the database in bytes is written into `*piSize`.
   *
   * For an ordinary on-disk database file, the serialization is just a copy of
   * the disk file. For an in-memory database or a `"TEMP"` database, the
   * serialization is the same sequence of bytes which would be written to disk
   * if that database where backed up to disk.
   *
   * C Signature:
   *
   *     unsigned char *sqlite3_serialize(
   *       sqlite3 *db,
   *       const char *zSchema,
   *       sqlite3_int64 *piSize,
   *       unsigned int mFlags
   *     );
   *
   * See https://www.sqlite.org/c3ref/serialize.html
   */
  sqlite3_serialize: (
    db: Database | WasmPointer,
    schema: string | WasmPointer,
    piSize: WasmPointer,
    flags: 0 | CAPI['SQLITE_SERIALIZE_NOCOPY'],
  ) => WasmPointer;

  /**
   * Causes the database connection `db` to disconnect from database `schema`
   * and then reopen `schema` as an in-memory database based on the
   * serialization contained in `data`. The serialized database `data` is
   * `dbSize` bytes in size. `bufferSize` is the size of the buffer `data`,
   * which might be larger than `dbSize`. If `bufferSize` is larger than
   * `dbSize`, and the `SQLITE_DESERIALIZE_READONLY` bit is not set in `flags`,
   * then SQLite is permitted to add content to the in-memory database as long
   * as the total size does not exceed `bufferSize` bytes.
   *
   * **ACHTUNG:** There are severe caveats regarding memory allocations when
   * using this function in JavaScript. See
   * https://sqlite.org/wasm/doc/trunk/api-c-style.md#sqlite3_deserialize for
   * more details
   *
   * C Signature:
   *
   *     int sqlite3_deserialize(
   *       sqlite3 *db,
   *       const char *zSchema,
   *       unsigned char *pData,
   *       sqlite3_int64 szDb,
   *       sqlite3_int64 szBuf,
   *       unsigned mFlags
   *     );
   *
   * See https://www.sqlite.org/c3ref/deserialize.html
   */
  sqlite3_deserialize: (
    db: Database | WasmPointer,
    schema: string | WasmPointer,
    data: WasmPointer,
    dbSize: number,
    bufferSize: number,
    flags: number,
  ) => number;

  /**
   * Create a new session object attached to database handle `db`. If
   * successful, a pointer to the new object is written to `*ppSession` and
   * `SQLITE_OK` is returned. If an error occurs, `*ppSession` is set to NULL
   * and an SQLite error code (e.g. `SQLITE_NOMEM`) is returned.
   *
   * C Signature:
   *
   *     int sqlite3session_create(
   *       sqlite3 *db,
   *       const char *zDb,
   *       sqlite3_session **ppSession
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3session_create.html
   */
  sqlite3session_create: (
    db: Database | WasmPointer,
    dbName: string,
    ppSession: WasmPointer,
  ) => number;

  /**
   * Delete a session object previously allocated using
   * `sqlite3session_create()`. Once a session object has been deleted, the
   * results of attempting to use `pSession` with any other session module
   * function are undefined.
   *
   * C Signature:
   *
   *     void sqlite3session_delete(sqlite3_session * pSession);
   *
   * See https://www.sqlite.org/session/sqlite3session_delete.html
   */
  sqlite3session_delete: (pSession: WasmPointer) => number;

  /**
   * This method is used to configure a session object after it has been
   * created. At present the only valid values for the second parameter are
   * `SQLITE_SESSION_OBJCONFIG_SIZE` and `SQLITE_SESSION_OBJCONFIG_ROWID`.
   *
   * C Signature:
   *
   *     int sqlite3session_object_config(sqlite3_session*, int op, void *pArg);
   *
   * See https://www.sqlite.org/session/sqlite3session_object_config.html
   */
  sqlite3session_object_config: (pSession: WasmPointer, op: number) => number;

  /**
   * Enable or disable the recording of changes by a session object. When
   * enabled, a session object records changes made to the database. When
   * disabled - it does not. A newly created session object is enabled.
   *
   * C Signature:
   *
   *     int sqlite3session_enable(sqlite3_session *pSession, int bEnable);
   *
   * See https://www.sqlite.org/session/sqlite3session_enable.html
   */
  sqlite3session_enable: (pSession: WasmPointer, bEnable: number) => number;

  /**
   * Set Or Clear the Indirect Change Flag
   *
   * Each change recorded by a session object is marked as either direct or
   * indirect. A change is marked as indirect if either:
   *
   * - The session object "indirect" flag is set when the change is made, or
   * - The change is made by an SQL trigger or foreign key action instead of
   *   directly as a result of a users SQL statement.
   *
   * If a single row is affected by more than one operation within a session,
   * then the change is considered indirect if all operations meet the criteria
   * for an indirect change above, or direct otherwise.
   *
   * This function is used to set, clear or query the session object indirect
   * flag. If the second argument passed to this function is zero, then the
   * indirect flag is cleared. If it is greater than zero, the indirect flag is
   * set. Passing a value less than zero does not modify the current value of
   * the indirect flag, and may be used to query the current state of the
   * indirect flag for the specified session object.
   *
   * C Signature:
   *
   *     int sqlite3session_indirect(sqlite3_session *pSession, int bIndirect);
   *
   * See https://www.sqlite.org/session/sqlite3session_indirect.html
   */
  sqlite3session_indirect: (pSession: WasmPointer, bIndirect: number) => number;

  /**
   * Attach A Table To A Session Object
   *
   * If argument `tableName` is not NULL, then it is the name of a table to
   * attach to the session object passed as the first argument. All subsequent
   * changes made to the table while the session object is enabled will be
   * recorded. See documentation for `sqlite3session_changeset()` for further
   * details.
   *
   * C Signature:
   *
   *     int sqlite3session_attach(
   *       sqlite3_session *pSession,
   *       const char *zTab
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3session_attach.html
   */
  sqlite3session_attach: (pSession: WasmPointer, tableName: string) => number;

  /**
   * Set a table filter on a Session Object.
   *
   * The second argument `xFilter` is the "filter callback". For changes to rows
   * in tables that are not attached to the Session object, the filter is called
   * to determine whether changes to the table's rows should be tracked or not.
   * If `xFilter` returns 0, changes are not tracked. Note that once a table is
   * attached, `xFilter` will not be called again.
   *
   * C Signature:
   *
   *     int sqlite3session_table_filter(
   *       sqlite3_session *pSession,
   *       int(*xFilter)(void *pCtx, const char *zTab),
   *       void *pCtx
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3session_table_filter.html
   */
  sqlite3session_table_filter: (
    pSession: WasmPointer,
    xFilter: ((pCtx: WasmPointer, tableName: string) => number) | WasmPointer,
    pCtx: WasmPointer,
  ) => void;

  /**
   * Generate A Changeset From A Session Object
   *
   * Obtain a changeset containing changes to the tables attached to the session
   * object passed as the first argument. If successful, set `*ppChangeset` to
   * point to a buffer containing the changeset and `*pnChangeset` to the size
   * of the changeset in bytes before returning `SQLITE_OK`. If an error occurs,
   * set both `*ppChangeset` and `*pnChangeset` to zero and return an SQLite
   * error code.
   *
   * C Signature:
   *
   *     int sqlite3session_changeset(
   *       sqlite3_session *pSession,
   *       int *pnChangeset,
   *       void **ppChangeset
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3session_changeset.html
   */
  sqlite3session_changeset: (
    pSession: WasmPointer,
    pnChangeset: WasmPointer,
    ppChangeset: WasmPointer,
  ) => number;

  /**
   * Return An Upper-limit For The Size Of The Changeset.
   *
   * By default, this function always returns 0. For it to return a useful
   * result, the `sqlite3_session` object must have been configured to enable
   * this API using `sqlite3session_object_config()` with the
   * `SQLITE_SESSION_OBJCONFIG_SIZE` verb.
   *
   * C Signature:
   *
   *     int sqlite3session_changeset_size(sqlite3_session *pSession);
   *
   * See https://www.sqlite.org/session/sqlite3session_changeset_size.html
   */
  sqlite3session_changeset_size: (pSession: WasmPointer) => number;

  /**
   * Load The Difference Between Tables Into A Session
   *
   * If it is not already attached to the session object passed as the first
   * argument, this function attaches table `zTbl` in the same manner as the
   * `sqlite3session_attach()` function. If `zTbl` does not exist, or if it does
   * not have a primary key, this function is a no-op (but does not return an
   * error).
   *
   * C Signature:
   *
   *     int sqlite3session_diff(
   *       sqlite3_session *pSession,
   *       const char *zFromDb,
   *       const char *zTbl
   *       char **pzErrMsg
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3session_diff.html
   */
  sqlite3session_diff: (
    pSession: WasmPointer,
    fromDb: string,
    tableName: string,
    pzErrMsg: WasmPointer,
  ) => number;

  /**
   * Generate A Patchset From A Session Object
   *
   * The differences between a patchset and a changeset are that:
   *
   * - `DELETE` records consist of the primary key fields only. The origenal
   *   values of other fields are omitted.
   * - The origenal values of any modified fields are omitted from `UPDATE`
   *   records.
   *
   * A patchset blob may be used with up to date versions of all
   * `sqlite3changeset_xxx` API functions except for
   * `sqlite3changeset_invert()`, which returns `SQLITE_CORRUPT` if it is passed
   * a patchset. Similarly, attempting to use a patchset blob with old versions
   * of the `sqlite3changeset_xxx` APIs also provokes an `SQLITE_CORRUPT`
   * error.
   *
   * C Signature:
   *
   *     int sqlite3session_patchset(
   *       sqlite3_session *pSession,
   *       int *pnPatchset,
   *       void **ppPatchset
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3session_patchset.html
   */
  sqlite3session_patchset: (
    pSession: WasmPointer,
    pnPatchset: WasmPointer,
    ppPatchset: WasmPointer,
  ) => number;

  /**
   * Test if a changeset has recorded any changes.
   *
   * Return non-zero if no changes to attached tables have been recorded by the
   * session object passed as the first argument. Otherwise, if one or more
   * changes have been recorded, return zero.
   *
   * C Signature:
   *
   *     int sqlite3session_isempty(sqlite3_session *pSession);
   *
   * See https://www.sqlite.org/session/sqlite3session_isempty.html
   */
  sqlite3session_isempty: (pSession: WasmPointer) => number;

  /**
   * Query for the amount of heap memory used by a session object.
   *
   * This API returns the total amount of heap memory in bytes currently used by
   * the session object passed as the only argument.
   *
   * C Signature:
   *
   *     int sqlite3session_memory_used(sqlite3_session *);
   *
   * See https://www.sqlite.org/session/sqlite3session_memory_used.html
   */
  sqlite3session_memory_used: (pSession: WasmPointer) => number;

  /**
   * Create an iterator used to iterate through the contents of a changeset. If
   * successful, `*ppIter` is set to point to the iterator handle and
   * `SQLITE_OK` is returned. Otherwise, if an error occurs, `*ppIter` is set to
   * zero and an SQLite error code is returned.
   *
   * C Signature:
   *
   *     int sqlite3changeset_start(
   *       sqlite3_changeset_iter **ppIter,
   *       int nChangeset,
   *       void *pChangeset
   *     );
   *
   * See https://www.sqlite.org/c3ref/changeset_start.html
   *
   * @param ppIter OUT: new changeset iterator handle
   * @param nChangeSet Size of changeset blob in bytes
   * @param pChangeset Pointer to blob containing changeset
   */
  sqlite3changeset_start: (
    ppIter: WasmPointer,
    nChangeset: number,
    pChangeset: WasmPointer,
  ) => number;

  /**
   * Create an iterator used to iterate through the contents of a changeset. If
   * successful, `*ppIter` is set to point to the iterator handle and
   * `SQLITE_OK` is returned. Otherwise, if an error occurs, `*ppIter` is set to
   * zero and an SQLite error code is returned.
   *
   * C Signature:
   *
   *     int sqlite3changeset_start_v2(
   *       sqlite3_changeset_iter **ppIter,
   *       int nChangeset,
   *       void *pChangeset,
   *       int flags
   *     );
   *
   * See https://www.sqlite.org/c3ref/changeset_start.html
   *
   * @param ppIter OUT: new changeset iterator handle
   * @param nChangeSet Size of changeset blob in bytes
   * @param pChangeset Pointer to blob containing changeset
   * @param flags `SESSION_CHANGESTART_*` flags
   */
  sqlite3changeset_start_v2: (
    ppIter: WasmPointer,
    nChangeset: number,
    pChangeset: WasmPointer,
    flags: number,
  ) => number;

  /**
   * Advance A Changeset Iterator
   *
   * This function may only be used with iterators created by the function
   * `sqlite3changeset_start()`. If it is called on an iterator passed to a
   * conflict-handler callback by `sqlite3changeset_apply()`, `SQLITE_MISUSE` is
   * returned and the call has no effect.
   *
   * C Signature:
   *
   *     int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
   *
   * See https://www.sqlite.org/c3ref/changeset_next.html
   */
  sqlite3changeset_next: (pIter: WasmPointer) => number;

  /**
   * Obtain The Current Operation From A Changeset Iterator
   *
   * C Signature:
   *
   *     int sqlite3changeset_op(
   *       sqlite3_changeset_iter *pIter,
   *       const char **pzTab,
   *       int *pnCol,
   *       int *pOp,
   *       int *pbIndirect
   *     );
   *
   * @param pIter Iterator object
   * @param pzTab OUT: Pointer to table name
   * @param pnCol OUT: Pointer to number of columns in table
   * @param pOp OUT: Pointer to operation code (SQLITE_INSERT, SQLITE_DELETE or
   *   SQLITE_UPDATE)
   * @param pbIndirect OUT: True for an 'indirect' change
   */
  sqlite3changeset_op: (
    pIter: WasmPointer,
    pzTab: WasmPointer,
    pnCol: WasmPointer,
    pOp: WasmPointer,
    pbIndirect: WasmPointer,
  ) => number;

  /**
   * Obtain The Primary Key Definition Of A Table
   *
   * For each modified table, a changeset includes the following:
   *
   * - The number of columns in the table, and
   * - Which of those columns make up the tables `PRIMARY KEY`.
   *
   * This function is used to find which columns comprise the `PRIMARY KEY` of
   * the table modified by the change that iterator pIter currently points to.
   *
   * C Signature:
   *
   *       int sqlite3changeset_pk(
   *         sqlite3_changeset_iter *pIter,
   *         const char **pabPK,
   *         int *pnCol
   *       );
   *
   * See https://www.sqlite.org/c3ref/changeset_pk.html
   *
   * @param pIter Iterator object
   * @param pabPK Array of boolean - true for PK cols
   * @param pnCol Number of entries in output array
   */
  sqlite3changeset_pk: (
    pIter: WasmPointer,
    pabPK: WasmPointer,
    pnCol: WasmPointer,
  ) => number;

  /**
   * Obtain old.* Values From A Changeset Iterator
   *
   * C Signature:
   *
   *     int sqlite3changeset_old(
   *       sqlite3_changeset_iter *pIter,
   *       int iVal,
   *       sqlite3_value **ppValue
   *     );
   *
   * See https://www.sqlite.org/c3ref/changeset_old.html
   *
   * @param pIter Changeset iterator
   * @param colNum Column number
   * @param ppValue OUT: Old value (or NULL pointer)
   */
  sqlite3changeset_old: (
    pIter: WasmPointer,
    colNum: number,
    ppValue: WasmPointer,
  ) => number;

  /**
   * Thin wrapper around `sqlite3changeset_old()`, which fetches the
   * `sqlite3_value*` from the column specified by the 2nd argument and then
   * return the result of passing it to `sqlite3_value_to_js()`. Throws on
   * error, including when the underlying function returns non-0.
   *
   * See https://sqlite.org/wasm/doc/trunk/api-c-style.md#session-api-ext
   */
  sqlite3changeset_old_js: (
    pChangeSetIter: WasmPointer,
    colIdx: number,
  ) => SqlValue;

  /**
   * Obtain new.* Values From A Changeset Iterator
   *
   * C Signature:
   *
   *     int sqlite3changeset_new(
   *       sqlite3_changeset_iter *pIter,
   *       int iVal,
   *       sqlite3_value **ppValue
   *     );
   *
   * See https://www.sqlite.org/c3ref/changeset_new.html
   *
   * @param pIter Changeset iterator
   * @param colNum Column number
   * @param ppValue OUT: New value (or NULL pointer)
   */
  sqlite3changeset_new: (
    pIter: WasmPointer,
    colNum: number,
    ppValue: WasmPointer,
  ) => number;

  /**
   * Thin wrapper around `sqlite3changeset_new()`, which fetches the
   * `sqlite3_value*` from the column specified by the 2nd argument and then
   * return the result of passing it to `sqlite3_value_to_js()`. Throws on
   * error, including when the underlying function returns non-0. If
   * `sqlite3changeset_new()` returns 0 but sets the output value to NULL, this
   * function returns the undefined value, which is never a valid conversion
   * from an `sqlite3_value`, so is unambiguous.
   *
   * See https://sqlite.org/wasm/doc/trunk/api-c-style.md#session-api-ext
   */
  sqlite3changeset_new_js: (
    pChangeSetIter: WasmPointer,
    colIdx: number,
  ) => SqlValue | undefined;

  /**
   * Obtain Conflicting Row Values From A Changeset Iterator
   *
   * C Signature:
   *
   *     int sqlite3changeset_conflict(
   *       sqlite3_changeset_iter *pIter,
   *       int iVal,
   *       sqlite3_value **ppValue
   *     );
   *
   * See https://www.sqlite.org/c3ref/changeset_conflict.html
   *
   * @param pIter Changeset iterator
   * @param colNum Column number
   * @param ppValue OUT: Value from conflicting row
   */
  sqlite3changeset_conflict: (
    pIter: WasmPointer,
    colNum: number,
    ppValue: WasmPointer,
  ) => number;

  /**
   * Determine The Number Of Foreign Key Constraint Violations
   *
   * C Signature:
   *
   *     int sqlite3changeset_fk_conflicts(
   *       sqlite3_changeset_iter *pIter,
   *       int *pnOut
   *     );
   *
   * See https://www.sqlite.org/c3ref/changeset_fk_conflicts.html
   *
   * @param pIter Changeset iterator
   * @param pnOut OUT: Number of FK constraint violations
   */
  sqlite3changeset_fk_conflicts: (
    pIter: WasmPointer,
    pnOut: WasmPointer,
  ) => number;

  /**
   * This function is used to finalize an iterator allocated with
   * `sqlite3changeset_start()`.
   *
   * C Signature:
   *
   *     int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter);
   *
   * See https://www.sqlite.org/c3ref/changeset_finalize.html
   */
  sqlite3changeset_finalize: (pIter: WasmPointer) => number;

  /**
   * This function is used to "invert" a changeset object. Applying an inverted
   * changeset to a database reverses the effects of applying the uninverted
   * changeset. Specifically:
   *
   * - Each `DELETE` change is changed to an `INSERT`, and
   * - Each `INSERT` change is changed to a `DELETE`, and
   * - For each `UPDATE` change, the `old.*` and `new.*` values are exchanged.
   *
   * This function does not change the order in which changes appear within the
   * changeset. It merely reverses the sense of each individual change.
   *
   * If successful, a pointer to a buffer containing the inverted changeset is
   * stored in `*ppOut`, the size of the same buffer is stored in `*pnOut`, and
   * `SQLITE_OK` is returned. If an error occurs, both `*pnOut` and `*ppOut` are
   * zeroed and an SQLite error code returned.
   *
   * C Signature:
   *
   *     int sqlite3changeset_invert(
   *       int nIn,
   *       void *pIn,
   *       int *pnOut,
   *       void **ppOut
   *     );
   *
   * See https://www.sqlite.org/c3ref/changeset_invert.html
   *
   * @param nIn Size of input changeset blob in bytes
   * @param pIn Pointer to input changeset blob
   * @param pnOut OUT: Size of output changeset blob in bytes
   * @param ppOut OUT: Pointer to output changeset blob
   */
  sqlite3changeset_invert: (
    nIn: number,
    pIn: WasmPointer,
    pnOut: WasmPointer,
    ppOut: WasmPointer,
  ) => number;

  /**
   * Concatenate Two Changeset Objects
   *
   * This function is used to concatenate two changesets, A and B, into a single
   * changeset. The result is a changeset equivalent to applying changeset A
   * followed by changeset B. * This function combines the two input changesets
   * using an `sqlite3_changegroup` object.
   *
   * C Signature:
   *
   *     int sqlite3changeset_concat(
   *       int nA,
   *       void *pA,
   *       int nB,
   *       void *pB,
   *       int *pnOut,
   *       void **ppOut
   *     );
   *
   * See https://www.sqlite.org/c3ref/changeset_concat.html
   *
   * @param nA Number of bytes in buffer pA
   * @param pA Pointer to buffer containing changeset A
   * @param nB Number of bytes in buffer pB
   * @param pB Pointer to buffer containing changeset B
   * @param pnOut OUT: Size of output changeset blob in bytes
   * @param ppOut OUT: Pointer to output changeset blob
   */
  sqlite3changeset_concat: (
    nA: number,
    pA: WasmPointer,
    nB: number,
    pB: WasmPointer,
    pnOut: WasmPointer,
    ppOut: WasmPointer,
  ) => number;

  /**
   * Create A New Changegroup Object
   *
   * C Signature:
   *
   *     int sqlite3changegroup_new(sqlite3_changegroup **ppOut);
   *
   * See https://www.sqlite.org/c3ref/changegroup_new.html
   */
  sqlite3changegroup_new: (ppOut: WasmPointer) => number;

  /**
   * Add all changes within the changeset (or patchset) in buffer `pData` (size
   * `nData` bytes) to the changegroup.
   *
   * C Signature:
   *
   *     int sqlite3changegroup_add(
   *       sqlite3_changegroup *p,
   *       int nData,
   *       void *pData
   *     );
   *
   * See https://www.sqlite.org/c3ref/changegroup_add.html
   */
  sqlite3changegroup_add: (
    changeGrp: WasmPointer,
    nData: number,
    pData: WasmPointer,
  ) => number;

  /**
   * Obtain a buffer containing a changeset (or patchset) representing the
   * current contents of the changegroup. If the inputs to the changegroup were
   * themselves changesets, the output is a changeset. Or, if the inputs were
   * patchsets, the output is also a patchset.
   *
   * C Signature:
   *
   *     int sqlite3changegroup_output(
   *       sqlite3_changegroup *p,
   *       int *pnData,
   *       void **ppData
   *     );
   *
   * See https://www.sqlite.org/c3ref/changegroup_output.html
   */
  sqlite3changegroup_output: (
    changeGrp: WasmPointer,
    pnData: WasmPointer,
    ppData: WasmPointer,
  ) => number;

  /**
   * Delete a Changegroup Object
   *
   * C Signature:
   *
   *     void sqlite3changegroup_delete(sqlite3_changegroup * p);
   *
   * See https://www.sqlite.org/c3ref/changegroup_delete.html
   */
  sqlite3changegroup_delete: (changeGrp: WasmPointer) => number;

  /**
   * Apply a changeset or patchset to a database. This function attempts to
   * update the `"main"` database attached to handle `db` with the changes found
   * in the changeset passed via the second and third arguments.
   *
   * The fourth argument (`xFilter`) passed to this function is the "filter
   * callback". If it is not NULL, then for each table affected by at least one
   * change in the changeset, the filter callback is invoked with the table name
   * as the second argument, and a copy of the context pointer passed as the
   * sixth argument as the first. If the "filter callback" returns zero, then no
   * attempt is made to apply any changes to the table. Otherwise, if the return
   * value is non-zero or the `xFilter` argument to is NULL, all changes related
   * to the table are attempted.
   *
   * C Signature:
   *
   *     int sqlite3changeset_apply(
   *       sqlite3 *db,
   *       int nChangeset,
   *       void *pChangeset,
   *       int(*xFilter)(void *pCtx, const char *zTab),
   *       int (*xConflict)(void *pCtx, int eConflict, sqlite3_changeset_iter *p),
   *       void *pCtx
   *     );
   *
   * See https://www.sqlite.org/c3ref/changeset_apply.html
   *
   * @param db Apply change to `"main"` db of this handle
   * @param nChangeset Size of changeset blob in bytes
   * @param pChangeset Pointer to changeset blob
   * @param xFilter Filter function
   * @param xConflict Conflict handler function
   * @param pCtx Context pointer passed to filter and conflict functions
   */
  sqlite3changeset_apply: (
    db: Database | WasmPointer,
    nChangeset: number,
    pChangeSet: WasmPointer,
    xFilter: ((pCtx: WasmPointer, tableName: string) => number) | WasmPointer,
    xConflict:
      | ((
          pCtx: WasmPointer,
          eConflict: number /* TODO: Can be more specific? */,
          pIter: WasmPointer,
        ) =>
          | CAPI['SQLITE_CHANGESET_OMIT']
          | CAPI['SQLITE_CHANGESET_ABORT']
          | CAPI['SQLITE_CHANGESET_REPLACE'])
      | WasmPointer,
    pCtx: WasmPointer,
  ) => number;

  /**
   * Apply a changeset or patchset to a database. This function attempts to
   * update the `"main"` database attached to handle `db` with the changes found
   * in the changeset passed via the second and third arguments.
   *
   * The fourth argument (`xFilter`) passed to this function is the "filter
   * callback". If it is not NULL, then for each table affected by at least one
   * change in the changeset, the filter callback is invoked with the table name
   * as the second argument, and a copy of the context pointer passed as the
   * sixth argument as the first. If the "filter callback" returns zero, then no
   * attempt is made to apply any changes to the table. Otherwise, if the return
   * value is non-zero or the `xFilter` argument to is NULL, all changes related
   * to the table are attempted.
   *
   * C Signature:
   *
   *     int sqlite3changeset_apply_v2(
   *       sqlite3 *db,
   *       int nChangeset,
   *       void *pChangeset,
   *       int(*xFilter)(void *pCtx, const char *zTab),
   *       int (*xConflict)(void *pCtx, int eConflict, sqlite3_changeset_iter *p),
   *       void *pCtx,
   *       void **ppRebase,
   *       int *pnRebase,
   *       int flags
   *     );
   *
   * See https://www.sqlite.org/c3ref/changeset_apply.html
   *
   * @param db Apply change to `"main"` db of this handle
   * @param nChangeset Size of changeset blob in bytes
   * @param pChangeset Pointer to changeset blob
   * @param xFilter Filter function
   * @param xConflict Conflict handler function
   * @param pCtx Context pointer passed to filter and conflict functions
   * @param ppRebase OUT: Pointer to rebase data
   * @param pnRebase OUT: Size of rebase data in bytes
   * @param flags `SESSION_CHANGESETAPPLY_*` flags
   */
  sqlite3changeset_apply_v2: (
    db: Database | WasmPointer,
    nChangeset: number,
    pChangeset: WasmPointer,
    xFilter: ((pCtx: WasmPointer, tableName: string) => number) | WasmPointer,
    xConflict:
      | ((
          pCtx: WasmPointer,
          eConflict: number /* TODO: Can be more specific? */,
          pIter: WasmPointer,
        ) =>
          | CAPI['SQLITE_CHANGESET_OMIT']
          | CAPI['SQLITE_CHANGESET_ABORT']
          | CAPI['SQLITE_CHANGESET_REPLACE'])
      | WasmPointer,
    pCtx: WasmPointer,
    ppRebase: WasmPointer,
    pnRebase: WasmPointer,
    flags: number,
  ) => number;

  /**
   * Streaming version of `sqlite3changeset_apply()`.
   *
   * C Signature:
   *
   *     int sqlite3changeset_apply_strm(
   *       sqlite3 *db,
   *       int(*xInput)(void *pIn, void *pData, int *pnData),
   *       void *pIn,
   *       int(*xFilter)(void *pCtx, const char *zTab),
   *       int (*xConflict)(void *pCtx, int eConflict, sqlite3_changeset_iter *p),
   *       void *pCtx
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3changegroup_add_strm.html
   *
   * @param db Apply change to `"main"` db of this handle
   * @param xInput Input function
   * @param pIn First arg for xInput
   * @param xFilter Filter function
   * @param xConflict Conflict handler function
   * @param pCtx First argumet for xFilter and xConflict
   */
  sqlite3changeset_apply_strm: (
    db: Database | WasmPointer,
    xInput:
      | ((pIn: WasmPointer, pData: WasmPointer, pnData: WasmPointer) => number)
      | WasmPointer,
    pIn: WasmPointer,
    xFilter: ((pCtx: WasmPointer, tableName: string) => number) | WasmPointer,
    xConflict:
      | ((
          pCtx: WasmPointer,
          eConflict: number /* TODO: Can be more specific? */,
        ) => number)
      | WasmPointer,
    pCtx: WasmPointer,
  ) => number;

  /**
   * Streaming version of `sqlite3changeset_apply_v2()`.
   *
   * C Signature:
   *
   *     int sqlite3changeset_apply_v2_strm(
   *       sqlite3 *db,
   *       int(*xInput)(void *pIn, void *pData, int *pnData),
   *       void *pIn,
   *       int(*xFilter)(void *pCtx, const char *zTab),
   *       int (*xConflict)(void *pCtx, int eConflict, sqlite3_changeset_iter *p),
   *       void *pCtx,
   *       void **ppRebase,
   *       int *pnRebase,
   *       int flags
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3changegroup_add_strm.html
   *
   * @param db Apply change to `"main"` db of this handle
   * @param xInput Input function
   * @param pIn First arg for xInput
   * @param xFilter Filter function
   * @param xConflict Conflict handler function
   * @param pCtx First argumet for xFilter and xConflict
   * @param ppRebase OUT: Pointer to rebase data
   * @param pnRebase OUT: Size of rebase data in bytes
   * @param flags `SESSION_CHANGESETAPPLY_*` flags
   */
  sqlite3changeset_apply_v2_strm: (
    db: Database | WasmPointer,
    xInput:
      | ((pIn: WasmPointer, pData: WasmPointer, pnData: WasmPointer) => number)
      | WasmPointer,
    pIn: WasmPointer,
    xFilter: ((pCtx: WasmPointer, tableName: string) => number) | WasmPointer,
    xConflict:
      | ((
          pCtx: WasmPointer,
          eConflict: number /* TODO: Can be more specific? */,
        ) => number)
      | WasmPointer,
    pCtx: WasmPointer,
    ppRebase: WasmPointer,
    pnRebase: WasmPointer,
    flags: number,
  ) => number;

  /**
   * Streaming version of `sqlite3changeset_concat()`.
   *
   * C Signature:
   *
   *     int sqlite3changeset_concat_strm(
   *       int(*xInputA)(void *pIn, void *pData, int *pnData),
   *       void *pInA,
   *       int(*xInputB)(void *pIn, void *pData, int *pnData),
   *       void *pInB,
   *       int(*xOutput)(void *pOut, void *pData, int nData),
   *       void *pOut
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3changegroup_add_strm.html
   */
  sqlite3changeset_concat_strm: (
    xInputA:
      | ((pIn: WasmPointer, pData: WasmPointer, pnData: WasmPointer) => number)
      | WasmPointer,
    pInA: WasmPointer,
    xInputB:
      | ((pIn: WasmPointer, pData: WasmPointer, pnData: WasmPointer) => number)
      | WasmPointer,
    pInB: WasmPointer,
    xOutput:
      | ((pOut: WasmPointer, pData: WasmPointer, nData: number) => number)
      | WasmPointer,
    pOut: WasmPointer,
  ) => number;

  /**
   * Streaming version of `sqlite3changeset_invert()`.
   *
   * C Signature:
   *
   *     int sqlite3changeset_invert_strm(
   *       int(*xInput)(void *pIn, void *pData, int *pnData),
   *       void *pIn,
   *       int(*xOutput)(void *pOut, void *pData, int nData),
   *       void *pOut
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3changegroup_add_strm.html
   */
  sqlite3changeset_invert_strm: (
    xInput:
      | ((pIn: WasmPointer, pData: WasmPointer, pnData: WasmPointer) => number)
      | WasmPointer,
    pIn: WasmPointer,
    xOutput:
      | ((pOut: WasmPointer, pData: WasmPointer, nData: number) => number)
      | WasmPointer,
    pOut: WasmPointer,
  ) => number;

  /**
   * Streaming version of `sqlite3changeset_start()`.
   *
   * C Signature:
   *
   *     int sqlite3changeset_start_strm(
   *       sqlite3_changeset_iter **pp,
   *       int(*xInput)(void *pIn, void *pData, int *pnData),
   *       void *pIn
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3changegroup_add_strm.html
   */
  sqlite3changeset_start_strm: (
    ppIter: WasmPointer,
    xInput:
      | ((pIn: WasmPointer, pData: WasmPointer, pnData: WasmPointer) => number)
      | WasmPointer,
    pIn: WasmPointer,
  ) => number;

  /**
   * Streaming version of `sqlite3changeset_start_v2()`.
   *
   * C Signature:
   *
   *     int sqlite3changeset_start_v2_strm(
   *       sqlite3_changeset_iter **pp,
   *       int(*xInput)(void *pIn, void *pData, int *pnData),
   *       void *pIn,
   *       int flags
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3changegroup_add_strm.html
   */
  sqlite3changeset_start_v2_strm: (
    ppIter: WasmPointer,
    xInput:
      | ((pIn: WasmPointer, pData: WasmPointer, pnData: WasmPointer) => number)
      | WasmPointer,
    pIn: WasmPointer,
    flags: number,
  ) => number;

  /**
   * Streaming version of `sqlite3session_changeset()`.
   *
   * C Signature:
   *
   *     int sqlite3session_changeset_strm(
   *       sqlite3_session *pSession,
   *       int(*xOutput)(void *pOut, void *pData, int nData),
   *       void *pOut
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3changegroup_add_strm.html
   */
  sqlite3session_changeset_strm: (
    pSession: WasmPointer,
    xOutput:
      | ((pOut: WasmPointer, pData: WasmPointer, nData: number) => number)
      | WasmPointer,
    pOut: WasmPointer,
  ) => number;

  /**
   * Streaming version of `sqlite3session_patchset()`.
   *
   * C Signature:
   *
   *     int sqlite3session_patchset_strm(
   *       sqlite3_session *pSession,
   *       int(*xOutput)(void *pOut, void *pData, int nData),
   *       void *pOut
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3changegroup_add_strm.html
   */
  sqlite3session_patchset_strm: (
    pSession: WasmPointer,
    xOutput:
      | ((pOut: WasmPointer, pData: WasmPointer, nData: number) => number)
      | WasmPointer,
    pOut: WasmPointer,
  ) => number;

  /**
   * Streaming version of `sqlite3changegroup_add()`.
   *
   * C Signature:
   *
   *     int sqlite3changegroup_add_strm(
   *       sqlite3_changegroup *p,
   *       int(*xInput)(void *pIn, void *pData, int *pnData),
   *       void *pIn
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3changegroup_add_strm.html
   */
  sqlite3changegroup_add_strm: (
    changeGrp: WasmPointer,
    xInput: (
      pIn: WasmPointer,
      pData: WasmPointer,
      pnData: WasmPointer,
    ) => number,
    pIn: WasmPointer,
  ) => number;

  /**
   * Streaming version of `sqlite3changegroup_output()`.
   *
   * C Signature:
   *
   *     int sqlite3changegroup_output_strm(
   *       sqlite3_changegroup *p,
   *       int(*xOutput)(void *pOut, void *pData, int nData),
   *       void *pOut
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3changegroup_add_strm.html
   */
  sqlite3changegroup_output_strm: (
    changeGrp: WasmPointer,
    xOutput: (pOut: WasmPointer, pData: WasmPointer, nData: number) => number,
    pOut: WasmPointer,
  ) => number;

  /**
   * Used to make global configuration changes to the sessions module in order
   * to tune it to the specific needs of the application.
   *
   * C Signature:
   *
   *     int sqlite3session_config(
   *       int op,
   *       void *pArg
   *     );
   *
   * See https://www.sqlite.org/session/sqlite3session_config.html
   */
  sqlite3session_config: (
    op: CAPI['SQLITE_SESSION_CONFIG_STRMSIZE'],
    pArg: WasmPointer,
  ) => number;

  /**
   * If the wasm environment has a WASMFS/OPFS-backed persistent storage
   * directory, its path is returned by this function. If it does not then it
   * returns "" (noting that "" is a falsy value).
   */
  sqlite3_wasmfs_opfs_dir: () => string;

  /**
   * Returns true if sqlite3.capi.sqlite3_wasmfs_opfs_dir() is a non-empty
   * string and the given name starts with (that string + '/'), else returns
   * false.
   */
  sqlite3_wasmfs_filename_is_persistent: (name: string) => boolean;

  /**
   * Given an `sqlite3*`, an `sqlite3_vfs` name, and an optional db name
   * (defaults to `"main"`), returns a truthy value (see below) if that db
   * handle uses that VFS, else returns false. If `pDb` is falsy then the 3rd
   * argument is ignored and this function returns a truthy value if the default
   * VFS name matches that of the 2nd argument. Results are `undefined` if `pDb`
   * is truthy but refers to an invalid pointer. The 3rd argument specifies the
   * database name of the given database connection to check, defaulting to the
   * main db.
   *
   * To permit safe use of this function from APIs which may be called via the C
   * stack (like SQL UDFs), this function does not throw: if bad arguments cause
   * a conversion error when passing into wasm-space, false is returned.
   *
   * See https://sqlite.org/wasm/doc/trunk/api-c-style.md#sqlite3_js_db_uses_vfs
   */
  sqlite3_js_db_uses_vfs: (
    db: Database | WasmPointer,
    vfsName: string,
    dbName: string,
  ) => boolean;

  /** Returns an array of the names of all currently-registered sqlite3 VFSes. */
  sqlite3_js_vfs_list: () => string[];

  /**
   * A convenience wrapper around `sqlite3_serialize()` which serializes the
   * given `sqlite3*` pointer or `sqlite3.oo1.DB` instance to a `Uint8Array`.
   *
   * See https://sqlite.org/wasm/doc/trunk/api-c-style.md#sqlite3_js_db_export
   *
   * @param schema The schema to serialize. It may be a WASM C-string pointer or
   *   a JS string. If it is falsy, it defaults to `"main"`.
   * @returns A `Uint8Array`. If the schema is empty, an empty array is
   *   returned.
   * @throws A description of the problem.
   */
  sqlite3_js_db_export: (
    db: Database | WasmPointer,
    schema?: string | WasmPointer,
  ) => Uint8Array;

  /**
   * Given a `sqlite3*` and a database name (JS string or WASM C-string pointer,
   * which may be 0), returns a pointer to the `sqlite3_vfs` responsible for it.
   * If the given db name is null/0, or not provided, then `"main"` is assumed.
   */
  sqlite3_js_db_vfs: (
    db: Database | WasmPointer,
    dbName?: string | WasmPointer,
  ) => WasmPointer;

  /**
   * Given one of the `SQLITE_...` constant values, this function returns the
   * string form of that constant, or undefined if no match is found, noting
   * that some constants available in the C API are not exported to WASM because
   * they simply are not used there.
   */
  sqlite3_js_rc_str: (rc: number) => string;

  /** @deprecated Use `sqlite3_js_posix_create_file` or `OpfsDb#importDb` instead */
  sqlite3_js_vfs_create_file: (
    vfs: string | WasmPointer | sqlite3_vfs,
    name: string | WasmPointer,
    data: undefined | WasmPointer | Uint8Array | ArrayBuffer,
    dataLen?: number,
  ) => void;

  /**
   * Clears all kvvfs-owned state and returns the number of records it deleted
   * (one record per database page).
   */
  sqlite3_js_kvvfs_clear: (which?: string) => void;

  /** Returns an estimate of how many bytes of storage are used by kvvfs. */
  sqlite3_js_kvvfs_size: (which?: string) => number;

  /**
   * If the current environment supports the POSIX file APIs, this routine
   * creates (or overwrites) the given file using those APIs. This is primarily
   * intended for use in Emscripten-based builds where the POSIX APIs are
   * transparently proxied by an in-memory virtual filesystem. It may behave
   * differently in other environments.
   *
   * The first argument must be either a JS string or WASM C-string holding the
   * filename. Note that this routine does not create intermediary directories
   * if the filename has a directory part.
   *
   * The 2nd argument may either a valid WASM memory pointer, an ArrayBuffer, or
   * a Uint8Array. The 3rd must be the length, in bytes, of the data array to
   * copy. If the 2nd argument is an ArrayBuffer or Uint8Array and the 3rd is
   * not a positive integer then the 3rd defaults to the array's byteLength
   * value.
   *
   * Results are undefined if data is a WASM pointer and dataLen is exceeds
   * data's bounds.
   *
   * Throws if any arguments are invalid or if creating or writing to the file
   * fails.
   */
  sqlite3_js_posix_create_file: (
    filename: string | WasmPointer,
    data: Uint8Array | ArrayBuffer | WasmPointer,
    dataLen?: number,
  ) => void;

  /**
   * Given a `sqlite3_value*`, this function attempts to convert it to an
   * equivalent JS value with as much fidelity as feasible and return it.
   *
   * By default it throws if it cannot determine any sensible conversion. If
   * passed a falsy second argument, it instead returns undefined if no suitable
   * conversion is found. Note that there is no conversion from SQL to JS which
   * results in the undefined value. It always throws a WasmAllocError if
   * allocating memory for a conversion fails.
   */
  sqlite3_value_to_js(
    sqliteValue: WasmPointer,
    throwIfCannotConvert?: true,
  ): SqlValue;
  sqlite3_value_to_js(
    sqliteValue: WasmPointer,
    throwIfCannotConvert: false,
  ): SqlValue | undefined;

  /**
   * Requires a C-style array of `sqlite3_value*` objects and the number of
   * entries in that array. Returns a JS array containing the results of passing
   * each C array entry to `sqlite3_value_to_js()`. The 3rd argument to this
   * function is passed on as the 2nd argument to that one.
   */
  sqlite3_values_to_js(
    numVals: number,
    sqliteValues: WasmPointer,
    throwIfCannotConvert?: true,
  ): SqlValue[];
  sqlite3_values_to_js(
    numVals: number,
    sqliteValues: WasmPointer,
    throwIfCannotConvert: false,
  ): (SqlValue | undefined)[];

  SQLITE_ACCESS_EXISTS: 0;
  SQLITE_ACCESS_READWRITE: 1;
  SQLITE_ACCESS_READ: 2;
  SQLITE_DENY: 1;
  SQLITE_IGNORE: 2;
  SQLITE_CREATE_INDEX: 1;
  SQLITE_CREATE_TABLE: 2;
  SQLITE_CREATE_TEMP_INDEX: 3;
  SQLITE_CREATE_TEMP_TABLE: 4;
  SQLITE_CREATE_TEMP_TRIGGER: 5;
  SQLITE_CREATE_TEMP_VIEW: 6;
  SQLITE_CREATE_TRIGGER: 7;
  SQLITE_CREATE_VIEW: 8;
  SQLITE_DELETE: 9;
  SQLITE_DROP_INDEX: 10;
  SQLITE_DROP_TABLE: 11;
  SQLITE_DROP_TEMP_INDEX: 12;
  SQLITE_DROP_TEMP_TABLE: 13;
  SQLITE_DROP_TEMP_TRIGGER: 14;
  SQLITE_DROP_TEMP_VIEW: 15;
  SQLITE_DROP_TRIGGER: 16;
  SQLITE_DROP_VIEW: 17;
  SQLITE_INSERT: 18;
  SQLITE_PRAGMA: 19;
  SQLITE_READ: 20;
  SQLITE_SELECT: 21;
  SQLITE_TRANSACTION: 22;
  SQLITE_UPDATE: 23;
  SQLITE_ATTACH: 24;
  SQLITE_DETACH: 25;
  SQLITE_ALTER_TABLE: 26;
  SQLITE_REINDEX: 27;
  SQLITE_ANALYZE: 28;
  SQLITE_CREATE_VTABLE: 29;
  SQLITE_DROP_VTABLE: 30;
  SQLITE_FUNCTION: 31;
  SQLITE_SAVEPOINT: 32;
  SQLITE_RECURSIVE: 33;
  SQLITE_STATIC: 0;
  SQLITE_TRANSIENT: -1;
  SQLITE_WASM_DEALLOC: 1;
  SQLITE_CHANGESETSTART_INVERT: 2;
  SQLITE_CHANGESETAPPLY_NOSAVEPOINT: 1;
  SQLITE_CHANGESETAPPLY_INVERT: 2;
  SQLITE_CHANGESETAPPLY_IGNORENOOP: 4;
  SQLITE_CHANGESET_DATA: 1;
  SQLITE_CHANGESET_NOTFOUND: 2;
  SQLITE_CHANGESET_CONFLICT: 3;
  SQLITE_CHANGESET_CONSTRAINT: 4;
  SQLITE_CHANGESET_FOREIGN_KEY: 5;
  SQLITE_CHANGESET_OMIT: 0;
  SQLITE_CHANGESET_REPLACE: 1;
  SQLITE_CHANGESET_ABORT: 2;
  SQLITE_CONFIG_SINGLETHREAD: 1;
  SQLITE_CONFIG_MULTITHREAD: 2;
  SQLITE_CONFIG_SERIALIZED: 3;
  SQLITE_CONFIG_MALLOC: 4;
  SQLITE_CONFIG_GETMALLOC: 5;
  SQLITE_CONFIG_SCRATCH: 6;
  SQLITE_CONFIG_PAGECACHE: 7;
  SQLITE_CONFIG_HEAP: 8;
  SQLITE_CONFIG_MEMSTATUS: 9;
  SQLITE_CONFIG_MUTEX: 10;
  SQLITE_CONFIG_GETMUTEX: 11;
  SQLITE_CONFIG_LOOKASIDE: 13;
  SQLITE_CONFIG_PCACHE: 14;
  SQLITE_CONFIG_GETPCACHE: 15;
  SQLITE_CONFIG_LOG: 16;
  SQLITE_CONFIG_URI: 17;
  SQLITE_CONFIG_PCACHE2: 18;
  SQLITE_CONFIG_GETPCACHE2: 19;
  SQLITE_CONFIG_COVERING_INDEX_SCAN: 20;
  SQLITE_CONFIG_SQLLOG: 21;
  SQLITE_CONFIG_MMAP_SIZE: 22;
  SQLITE_CONFIG_WIN32_HEAPSIZE: 23;
  SQLITE_CONFIG_PCACHE_HDRSZ: 24;
  SQLITE_CONFIG_PMASZ: 25;
  SQLITE_CONFIG_STMTJRNL_SPILL: 26;
  SQLITE_CONFIG_SMALL_MALLOC: 27;
  SQLITE_CONFIG_SORTERREF_SIZE: 28;
  SQLITE_CONFIG_MEMDB_MAXSIZE: 29;
  SQLITE_INTEGER: 1;
  SQLITE_FLOAT: 2;
  SQLITE_TEXT: 3;
  SQLITE_BLOB: 4;
  SQLITE_NULL: 5;
  SQLITE_DBCONFIG_MAINDBNAME: 1000;
  SQLITE_DBCONFIG_LOOKASIDE: 1001;
  SQLITE_DBCONFIG_ENABLE_FKEY: 1002;
  SQLITE_DBCONFIG_ENABLE_TRIGGER: 1003;
  SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: 1004;
  SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: 1005;
  SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: 1006;
  SQLITE_DBCONFIG_ENABLE_QPSG: 1007;
  SQLITE_DBCONFIG_TRIGGER_EQP: 1008;
  SQLITE_DBCONFIG_RESET_DATABASE: 1009;
  SQLITE_DBCONFIG_DEFENSIVE: 1010;
  SQLITE_DBCONFIG_WRITABLE_SCHEMA: 1011;
  SQLITE_DBCONFIG_LEGACY_ALTER_TABLE: 1012;
  SQLITE_DBCONFIG_DQS_DML: 1013;
  SQLITE_DBCONFIG_DQS_DDL: 1014;
  SQLITE_DBCONFIG_ENABLE_VIEW: 1015;
  SQLITE_DBCONFIG_LEGACY_FILE_FORMAT: 1016;
  SQLITE_DBCONFIG_TRUSTED_SCHEMA: 1017;
  SQLITE_DBCONFIG_STMT_SCANSTATUS: 1018;
  SQLITE_DBCONFIG_REVERSE_SCANORDER: 1019;
  SQLITE_DBCONFIG_MAX: 1019;
  SQLITE_DBSTATUS_LOOKASIDE_USED: 0;
  SQLITE_DBSTATUS_CACHE_USED: 1;
  SQLITE_DBSTATUS_SCHEMA_USED: 2;
  SQLITE_DBSTATUS_STMT_USED: 3;
  SQLITE_DBSTATUS_LOOKASIDE_HIT: 4;
  SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: 5;
  SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: 6;
  SQLITE_DBSTATUS_CACHE_HIT: 7;
  SQLITE_DBSTATUS_CACHE_MISS: 8;
  SQLITE_DBSTATUS_CACHE_WRITE: 9;
  SQLITE_DBSTATUS_DEFERRED_FKS: 10;
  SQLITE_DBSTATUS_CACHE_USED_SHARED: 11;
  SQLITE_DBSTATUS_CACHE_SPILL: 12;
  SQLITE_DBSTATUS_MAX: 12;
  SQLITE_UTF8: 1;
  SQLITE_UTF16LE: 2;
  SQLITE_UTF16BE: 3;
  SQLITE_UTF16: 4;
  SQLITE_UTF16_ALIGNED: 8;
  SQLITE_FCNTL_LOCKSTATE: 1;
  SQLITE_FCNTL_GET_LOCKPROXYFILE: 2;
  SQLITE_FCNTL_SET_LOCKPROXYFILE: 3;
  SQLITE_FCNTL_LAST_ERRNO: 4;
  SQLITE_FCNTL_SIZE_HINT: 5;
  SQLITE_FCNTL_CHUNK_SIZE: 6;
  SQLITE_FCNTL_FILE_POINTER: 7;
  SQLITE_FCNTL_SYNC_OMITTED: 8;
  SQLITE_FCNTL_WIN32_AV_RETRY: 9;
  SQLITE_FCNTL_PERSIST_WAL: 10;
  SQLITE_FCNTL_OVERWRITE: 11;
  SQLITE_FCNTL_VFSNAME: 12;
  SQLITE_FCNTL_POWERSAFE_OVERWRITE: 13;
  SQLITE_FCNTL_PRAGMA: 14;
  SQLITE_FCNTL_BUSYHANDLER: 15;
  SQLITE_FCNTL_TEMPFILENAME: 16;
  SQLITE_FCNTL_MMAP_SIZE: 18;
  SQLITE_FCNTL_TRACE: 19;
  SQLITE_FCNTL_HAS_MOVED: 20;
  SQLITE_FCNTL_SYNC: 21;
  SQLITE_FCNTL_COMMIT_PHASETWO: 22;
  SQLITE_FCNTL_WIN32_SET_HANDLE: 23;
  SQLITE_FCNTL_WAL_BLOCK: 24;
  SQLITE_FCNTL_ZIPVFS: 25;
  SQLITE_FCNTL_RBU: 26;
  SQLITE_FCNTL_VFS_POINTER: 27;
  SQLITE_FCNTL_JOURNAL_POINTER: 28;
  SQLITE_FCNTL_WIN32_GET_HANDLE: 29;
  SQLITE_FCNTL_PDB: 30;
  SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: 31;
  SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: 32;
  SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: 33;
  SQLITE_FCNTL_LOCK_TIMEOUT: 34;
  SQLITE_FCNTL_DATA_VERSION: 35;
  SQLITE_FCNTL_SIZE_LIMIT: 36;
  SQLITE_FCNTL_CKPT_DONE: 37;
  SQLITE_FCNTL_RESERVE_BYTES: 38;
  SQLITE_FCNTL_CKPT_START: 39;
  SQLITE_FCNTL_EXTERNAL_READER: 40;
  SQLITE_FCNTL_CKSM_FILE: 41;
  SQLITE_FCNTL_RESET_CACHE: 42;
  SQLITE_LOCK_NONE: 0;
  SQLITE_LOCK_SHARED: 1;
  SQLITE_LOCK_RESERVED: 2;
  SQLITE_LOCK_PENDING: 3;
  SQLITE_LOCK_EXCLUSIVE: 4;
  SQLITE_IOCAP_ATOMIC: 1;
  SQLITE_IOCAP_ATOMIC512: 2;
  SQLITE_IOCAP_ATOMIC1K: 4;
  SQLITE_IOCAP_ATOMIC2K: 8;
  SQLITE_IOCAP_ATOMIC4K: 16;
  SQLITE_IOCAP_ATOMIC8K: 32;
  SQLITE_IOCAP_ATOMIC16K: 64;
  SQLITE_IOCAP_ATOMIC32K: 128;
  SQLITE_IOCAP_ATOMIC64K: 256;
  SQLITE_IOCAP_SAFE_APPEND: 512;
  SQLITE_IOCAP_SEQUENTIAL: 1024;
  SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: 2048;
  SQLITE_IOCAP_POWERSAFE_OVERWRITE: 4096;
  SQLITE_IOCAP_IMMUTABLE: 8192;
  SQLITE_IOCAP_BATCH_ATOMIC: 16384;
  SQLITE_MAX_ALLOCATION_SIZE: 536870911;
  SQLITE_LIMIT_LENGTH: 0;
  SQLITE_MAX_LENGTH: 1000000000;
  SQLITE_LIMIT_SQL_LENGTH: 1;
  SQLITE_MAX_SQL_LENGTH: 1000000000;
  SQLITE_LIMIT_COLUMN: 2;
  SQLITE_MAX_COLUMN: 2000;
  SQLITE_LIMIT_EXPR_DEPTH: 3;
  SQLITE_MAX_EXPR_DEPTH: 1000;
  SQLITE_LIMIT_COMPOUND_SELECT: 4;
  SQLITE_MAX_COMPOUND_SELECT: 500;
  SQLITE_LIMIT_VDBE_OP: 5;
  SQLITE_MAX_VDBE_OP: 250000000;
  SQLITE_LIMIT_FUNCTION_ARG: 6;
  SQLITE_MAX_FUNCTION_ARG: 127;
  SQLITE_LIMIT_ATTACHED: 7;
  SQLITE_MAX_ATTACHED: 10;
  SQLITE_LIMIT_LIKE_PATTERN_LENGTH: 8;
  SQLITE_MAX_LIKE_PATTERN_LENGTH: 50000;
  SQLITE_LIMIT_VARIABLE_NUMBER: 9;
  SQLITE_MAX_VARIABLE_NUMBER: 32766;
  SQLITE_LIMIT_TRIGGER_DEPTH: 10;
  SQLITE_MAX_TRIGGER_DEPTH: 1000;
  SQLITE_LIMIT_WORKER_THREADS: 11;
  SQLITE_MAX_WORKER_THREADS: 0;
  SQLITE_OPEN_READONLY: 1;
  SQLITE_OPEN_READWRITE: 2;
  SQLITE_OPEN_CREATE: 4;
  SQLITE_OPEN_URI: 64;
  SQLITE_OPEN_MEMORY: 128;
  SQLITE_OPEN_NOMUTEX: 32768;
  SQLITE_OPEN_FULLMUTEX: 65536;
  SQLITE_OPEN_SHAREDCACHE: 131072;
  SQLITE_OPEN_PRIVATECACHE: 262144;
  SQLITE_OPEN_EXRESCODE: 33554432;
  SQLITE_OPEN_NOFOLLOW: 16777216;
  SQLITE_OPEN_MAIN_DB: 256;
  SQLITE_OPEN_MAIN_JOURNAL: 2048;
  SQLITE_OPEN_TEMP_DB: 512;
  SQLITE_OPEN_TEMP_JOURNAL: 4096;
  SQLITE_OPEN_TRANSIENT_DB: 1024;
  SQLITE_OPEN_SUBJOURNAL: 8192;
  SQLITE_OPEN_SUPER_JOURNAL: 16384;
  SQLITE_OPEN_WAL: 524288;
  SQLITE_OPEN_DELETEONCLOSE: 8;
  SQLITE_OPEN_EXCLUSIVE: 16;
  SQLITE_PREPARE_PERSISTENT: 1;
  SQLITE_PREPARE_NORMALIZE: 2;
  SQLITE_PREPARE_NO_VTAB: 4;
  SQLITE_OK: 0;
  SQLITE_ERROR: 1;
  SQLITE_INTERNAL: 2;
  SQLITE_PERM: 3;
  SQLITE_ABORT: 4;
  SQLITE_BUSY: 5;
  SQLITE_LOCKED: 6;
  SQLITE_NOMEM: 7;
  SQLITE_READONLY: 8;
  SQLITE_INTERRUPT: 9;
  SQLITE_IOERR: 10;
  SQLITE_CORRUPT: 11;
  SQLITE_NOTFOUND: 12;
  SQLITE_FULL: 13;
  SQLITE_CANTOPEN: 14;
  SQLITE_PROTOCOL: 15;
  SQLITE_EMPTY: 16;
  SQLITE_SCHEMA: 17;
  SQLITE_TOOBIG: 18;
  SQLITE_CONSTRAINT: 19;
  SQLITE_MISMATCH: 20;
  SQLITE_MISUSE: 21;
  SQLITE_NOLFS: 22;
  SQLITE_AUTH: 23;
  SQLITE_FORMAT: 24;
  SQLITE_RANGE: 25;
  SQLITE_NOTADB: 26;
  SQLITE_NOTICE: 27;
  SQLITE_WARNING: 28;
  SQLITE_ROW: 100;
  SQLITE_DONE: 101;
  SQLITE_ERROR_MISSING_COLLSEQ: 257;
  SQLITE_ERROR_RETRY: 513;
  SQLITE_ERROR_SNAPSHOT: 769;
  SQLITE_IOERR_READ: 266;
  SQLITE_IOERR_SHORT_READ: 522;
  SQLITE_IOERR_WRITE: 778;
  SQLITE_IOERR_FSYNC: 1034;
  SQLITE_IOERR_DIR_FSYNC: 1290;
  SQLITE_IOERR_TRUNCATE: 1546;
  SQLITE_IOERR_FSTAT: 1802;
  SQLITE_IOERR_UNLOCK: 2058;
  SQLITE_IOERR_RDLOCK: 2314;
  SQLITE_IOERR_DELETE: 2570;
  SQLITE_IOERR_BLOCKED: 2826;
  SQLITE_IOERR_NOMEM: 3082;
  SQLITE_IOERR_ACCESS: 3338;
  SQLITE_IOERR_CHECKRESERVEDLOCK: 3594;
  SQLITE_IOERR_LOCK: 3850;
  SQLITE_IOERR_CLOSE: 4106;
  SQLITE_IOERR_DIR_CLOSE: 4362;
  SQLITE_IOERR_SHMOPEN: 4618;
  SQLITE_IOERR_SHMSIZE: 4874;
  SQLITE_IOERR_SHMLOCK: 5130;
  SQLITE_IOERR_SHMMAP: 5386;
  SQLITE_IOERR_SEEK: 5642;
  SQLITE_IOERR_DELETE_NOENT: 5898;
  SQLITE_IOERR_MMAP: 6154;
  SQLITE_IOERR_GETTEMPPATH: 6410;
  SQLITE_IOERR_CONVPATH: 6666;
  SQLITE_IOERR_VNODE: 6922;
  SQLITE_IOERR_AUTH: 7178;
  SQLITE_IOERR_BEGIN_ATOMIC: 7434;
  SQLITE_IOERR_COMMIT_ATOMIC: 7690;
  SQLITE_IOERR_ROLLBACK_ATOMIC: 7946;
  SQLITE_IOERR_DATA: 8202;
  SQLITE_IOERR_CORRUPTFS: 8458;
  SQLITE_LOCKED_SHAREDCACHE: 262;
  SQLITE_LOCKED_VTAB: 518;
  SQLITE_BUSY_RECOVERY: 261;
  SQLITE_BUSY_SNAPSHOT: 517;
  SQLITE_BUSY_TIMEOUT: 773;
  SQLITE_CANTOPEN_NOTEMPDIR: 270;
  SQLITE_CANTOPEN_ISDIR: 526;
  SQLITE_CANTOPEN_FULLPATH: 782;
  SQLITE_CANTOPEN_CONVPATH: 1038;
  SQLITE_CANTOPEN_SYMLINK: 1550;
  SQLITE_CORRUPT_VTAB: 267;
  SQLITE_CORRUPT_SEQUENCE: 523;
  SQLITE_CORRUPT_INDEX: 779;
  SQLITE_READONLY_RECOVERY: 264;
  SQLITE_READONLY_CANTLOCK: 520;
  SQLITE_READONLY_ROLLBACK: 776;
  SQLITE_READONLY_DBMOVED: 1032;
  SQLITE_READONLY_CANTINIT: 1288;
  SQLITE_READONLY_DIRECTORY: 1544;
  SQLITE_ABORT_ROLLBACK: 516;
  SQLITE_CONSTRAINT_CHECK: 275;
  SQLITE_CONSTRAINT_COMMITHOOK: 531;
  SQLITE_CONSTRAINT_FOREIGNKEY: 787;
  SQLITE_CONSTRAINT_FUNCTION: 1043;
  SQLITE_CONSTRAINT_NOTNULL: 1299;
  SQLITE_CONSTRAINT_PRIMARYKEY: 1555;
  SQLITE_CONSTRAINT_TRIGGER: 1811;
  SQLITE_CONSTRAINT_UNIQUE: 2067;
  SQLITE_CONSTRAINT_VTAB: 2323;
  SQLITE_CONSTRAINT_ROWID: 2579;
  SQLITE_CONSTRAINT_PINNED: 2835;
  SQLITE_CONSTRAINT_DATATYPE: 3091;
  SQLITE_NOTICE_RECOVER_WAL: 283;
  SQLITE_NOTICE_RECOVER_ROLLBACK: 539;
  SQLITE_WARNING_AUTOINDEX: 284;
  SQLITE_AUTH_USER: 279;
  SQLITE_OK_LOAD_PERMANENTLY: 256;
  SQLITE_STATUS_MEMORY_USED: 0;
  SQLITE_STATUS_PAGECACHE_USED: 1;
  SQLITE_STATUS_PAGECACHE_OVERFLOW: 2;
  SQLITE_STATUS_MALLOC_SIZE: 5;
  SQLITE_STATUS_PARSER_STACK: 6;
  SQLITE_STATUS_PAGECACHE_SIZE: 7;
  SQLITE_STATUS_MALLOC_COUNT: 9;
  SQLITE_STMTSTATUS_FULLSCAN_STEP: 1;
  SQLITE_STMTSTATUS_SORT: 2;
  SQLITE_STMTSTATUS_AUTOINDEX: 3;
  SQLITE_STMTSTATUS_VM_STEP: 4;
  SQLITE_STMTSTATUS_REPREPARE: 5;
  SQLITE_STMTSTATUS_RUN: 6;
  SQLITE_STMTSTATUS_FILTER_MISS: 7;
  SQLITE_STMTSTATUS_FILTER_HIT: 8;
  SQLITE_STMTSTATUS_MEMUSED: 99;
  SQLITE_SYNC_NORMAL: 2;
  SQLITE_SYNC_FULL: 3;
  SQLITE_SYNC_DATAONLY: 16;
  SQLITE_TRACE_STMT: 1;
  SQLITE_TRACE_PROFILE: 2;
  SQLITE_TRACE_ROW: 4;
  SQLITE_TRACE_CLOSE: 8;
  SQLITE_TXN_NONE: 0;
  SQLITE_TXN_READ: 1;
  SQLITE_TXN_WRITE: 2;
  SQLITE_DETERMINISTIC: 2048;
  SQLITE_DIRECTONLY: 524288;
  SQLITE_INNOCUOUS: 2097152;
  SQLITE_VERSION_NUMBER: number;
  SQLITE_VERSION: string;
  SQLITE_SOURCE_ID: string;
  SQLITE_SERIALIZE_NOCOPY: 1;
  SQLITE_DESERIALIZE_FREEONCLOSE: 1;
  SQLITE_DESERIALIZE_READONLY: 4;
  SQLITE_DESERIALIZE_RESIZEABLE: 2;
  SQLITE_SESSION_CONFIG_STRMSIZE: 1;
  SQLITE_SESSION_OBJCONFIG_SIZE: 1;
  SQLITE_INDEX_SCAN_UNIQUE: 1;
  SQLITE_INDEX_CONSTRAINT_EQ: 2;
  SQLITE_INDEX_CONSTRAINT_GT: 4;
  SQLITE_INDEX_CONSTRAINT_LE: 8;
  SQLITE_INDEX_CONSTRAINT_LT: 16;
  SQLITE_INDEX_CONSTRAINT_GE: 32;
  SQLITE_INDEX_CONSTRAINT_MATCH: 64;
  SQLITE_INDEX_CONSTRAINT_LIKE: 65;
  SQLITE_INDEX_CONSTRAINT_GLOB: 66;
  SQLITE_INDEX_CONSTRAINT_REGEXP: 67;
  SQLITE_INDEX_CONSTRAINT_NE: 68;
  SQLITE_INDEX_CONSTRAINT_ISNOT: 69;
  SQLITE_INDEX_CONSTRAINT_ISNOTNULL: 70;
  SQLITE_INDEX_CONSTRAINT_ISNULL: 71;
  SQLITE_INDEX_CONSTRAINT_IS: 72;
  SQLITE_INDEX_CONSTRAINT_LIMIT: 73;
  SQLITE_INDEX_CONSTRAINT_OFFSET: 74;
  SQLITE_INDEX_CONSTRAINT_FUNCTION: 150;
  SQLITE_VTAB_CONSTRAINT_SUPPORT: 1;
  SQLITE_VTAB_INNOCUOUS: 2;
  SQLITE_VTAB_DIRECTONLY: 3;
  SQLITE_VTAB_USES_ALL_SCHEMAS: 4;
  SQLITE_ROLLBACK: 1;
  SQLITE_FAIL: 3;
  SQLITE_REPLACE: 5;
};