///
// FIXME: Is this `any` really necessary?
type VariableArgFunction = (...params: any[]) => unknown;
type ArgumentTypes = F extends (...args: infer A) => unknown ? A : never;
type ElementOf = T extends Array ? E : T;
declare namespace BetterSqlite3 {
interface Statement {
database: Database;
source: string;
reader: boolean;
readonly: boolean;
busy: boolean;
run(...params: BindParameters): Database.RunResult;
get(...params: BindParameters): Result | undefined;
all(...params: BindParameters): Result[];
iterate(...params: BindParameters): IterableIterator;
pluck(toggleState?: boolean): this;
expand(toggleState?: boolean): this;
raw(toggleState?: boolean): this;
bind(...params: BindParameters): this;
columns(): ColumnDefinition[];
safeIntegers(toggleState?: boolean): this;
}
interface ColumnDefinition {
name: string;
column: string | null;
table: string | null;
database: string | null;
type: string | null;
}
interface Transaction {
(...params: ArgumentTypes): ReturnType;
default(...params: ArgumentTypes): ReturnType;
deferred(...params: ArgumentTypes): ReturnType;
immediate(...params: ArgumentTypes): ReturnType;
exclusive(...params: ArgumentTypes): ReturnType;
}
interface VirtualTableOptions {
rows: (...params: unknown[]) => Generator;
columns: string[];
parameters?: string[] | undefined;
safeIntegers?: boolean | undefined;
directOnly?: boolean | undefined;
}
interface Database {
memory: boolean;
readonly: boolean;
name: string;
open: boolean;
inTransaction: boolean;
prepare(
source: string,
): BindParameters extends unknown[] ? Statement : Statement<[BindParameters], Result>;
transaction(fn: F): Transaction;
exec(source: string): this;
pragma(source: string, options?: Database.PragmaOptions): unknown;
function(name: string, cb: (...params: unknown[]) => unknown): this;
function(name: string, options: Database.RegistrationOptions, cb: (...params: unknown[]) => unknown): this;
aggregate(
name: string,
options: Database.RegistrationOptions & {
start?: T | (() => T);
// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
step: (total: T, next: ElementOf) => T | void;
inverse?: ((total: T, dropped: T) => T) | undefined;
result?: ((total: T) => unknown) | undefined;
},
): this;
loadExtension(path: string): this;
close(): this;
defaultSafeIntegers(toggleState?: boolean): this;
backup(destinationFile: string, options?: Database.BackupOptions): Promise;
table(name: string, options: VirtualTableOptions): this;
unsafeMode(unsafe?: boolean): this;
serialize(options?: Database.SerializeOptions): Buffer;
}
interface DatabaseConstructor {
new(filename?: string | Buffer, options?: Database.Options): Database;
(filename?: string, options?: Database.Options): Database;
prototype: Database;
SqliteError: typeof SqliteError;
}
}
declare class SqliteError extends Error {
name: string;
message: string;
code: string;
constructor(message: string, code: string);
}
declare namespace Database {
interface RunResult {
changes: number;
lastInsertRowid: number | bigint;
}
interface Options {
readonly?: boolean | undefined;
fileMustExist?: boolean | undefined;
timeout?: number | undefined;
verbose?: ((message?: unknown, ...additionalArgs: unknown[]) => void) | undefined;
nativeBinding?: string | undefined;
}
interface SerializeOptions {
attached?: string;
}
interface PragmaOptions {
simple?: boolean | undefined;
}
interface RegistrationOptions {
varargs?: boolean | undefined;
deterministic?: boolean | undefined;
safeIntegers?: boolean | undefined;
directOnly?: boolean | undefined;
}
type AggregateOptions = Parameters[1];
interface BackupMetadata {
totalPages: number;
remainingPages: number;
}
interface BackupOptions {
progress: (info: BackupMetadata) => number;
}
type SqliteError = typeof SqliteError;
type Statement = BindParameters extends
unknown[] ? BetterSqlite3.Statement
: BetterSqlite3.Statement<[BindParameters], Result>;
type ColumnDefinition = BetterSqlite3.ColumnDefinition;
type Transaction = BetterSqlite3.Transaction;
type Database = BetterSqlite3.Database;
}
declare const Database: BetterSqlite3.DatabaseConstructor;
export = Database;