rado 0.1.8 → 0.1.9

package/dist/Query.d.ts

@@ -1,107 +1,107 @@
-import { ColumnData } from './Column';
-import { ExprData } from './Expr';
-import { OrderBy } from './OrderBy';
-import { Index, Schema } from './Schema';
-import { Target } from './Target';
-export declare enum QueryType {
-    Insert = "Insert",
-    Select = "Select",
-    Update = "Update",
-    Delete = "Delete",
-    CreateTable = "CreateTable",
-    CreateIndex = "CreateIndex",
-    DropIndex = "DropIndex",
-    AlterTable = "AlterTable",
-    Batch = "Batch",
-    Transaction = "Transaction",
-    Raw = "Raw"
-}
-export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
-export declare namespace Query {
-    interface QueryBase {
-        limit?: number;
-        offset?: number;
-        type: QueryType;
-        where?: ExprData;
-        orderBy?: Array<OrderBy>;
-        groupBy?: Array<ExprData>;
-        having?: ExprData;
-        selection?: ExprData;
-        singleResult?: boolean;
-    }
-    interface Insert extends QueryBase {
-        type: QueryType.Insert;
-        into: Schema;
-        data: Array<any>;
-    }
-    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
-    interface Select extends QueryBase {
-        type: QueryType.Select;
-        selection: ExprData;
-        from: Target;
-    }
-    function Select(select: Omit<Select, 'type'>): Query.Select;
-    interface Update extends QueryBase {
-        type: QueryType.Update;
-        table: Schema;
-        set?: Record<string, any>;
-    }
-    function Update(update: Omit<Update, 'type'>): Query.Update;
-    interface Delete extends QueryBase {
-        type: QueryType.Delete;
-        table: Schema;
-    }
-    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
-    interface CreateTable extends QueryBase {
-        type: QueryType.CreateTable;
-        table: Schema;
-        ifNotExists?: boolean;
-    }
-    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
-    interface CreateIndex extends QueryBase {
-        type: QueryType.CreateIndex;
-        table: Schema;
-        index: Index;
-        ifNotExists?: boolean;
-    }
-    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
-    interface DropIndex extends QueryBase {
-        type: QueryType.DropIndex;
-        table: Schema;
-        name: string;
-        ifExists?: boolean;
-    }
-    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
-    interface Batch extends QueryBase {
-        type: QueryType.Batch;
-        queries: Array<Query<any>>;
-    }
-    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
-    enum TransactionOperation {
-        Begin = "Begin",
-        Commit = "Commit",
-        Rollback = "Rollback"
-    }
-    interface Transaction extends QueryBase {
-        type: QueryType.Transaction;
-        id: string;
-        op: TransactionOperation;
-    }
-    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
-    type RawReturn = 'row' | 'rows' | undefined;
-    interface Raw extends QueryBase {
-        type: QueryType.Raw;
-        expectedReturn?: 'row' | 'rows';
-        strings: ReadonlyArray<string>;
-        params: Array<any>;
-    }
-    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
-    interface AlterTable extends QueryBase {
-        type: QueryType.AlterTable;
-        table: Schema;
-        alterColumn?: ColumnData;
-        addColumn?: ColumnData;
-        dropColumn?: string;
-    }
-    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
-}
+import { ColumnData } from './Column';
+import { ExprData } from './Expr';
+import { OrderBy } from './OrderBy';
+import { Index, Schema } from './Schema';
+import { Target } from './Target';
+export declare enum QueryType {
+    Insert = "Insert",
+    Select = "Select",
+    Update = "Update",
+    Delete = "Delete",
+    CreateTable = "CreateTable",
+    CreateIndex = "CreateIndex",
+    DropIndex = "DropIndex",
+    AlterTable = "AlterTable",
+    Batch = "Batch",
+    Transaction = "Transaction",
+    Raw = "Raw"
+}
+export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
+export declare namespace Query {
+    interface QueryBase {
+        limit?: number;
+        offset?: number;
+        type: QueryType;
+        where?: ExprData;
+        orderBy?: Array<OrderBy>;
+        groupBy?: Array<ExprData>;
+        having?: ExprData;
+        selection?: ExprData;
+        singleResult?: boolean;
+    }
+    interface Insert extends QueryBase {
+        type: QueryType.Insert;
+        into: Schema;
+        data: Array<any>;
+    }
+    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
+    interface Select extends QueryBase {
+        type: QueryType.Select;
+        selection: ExprData;
+        from: Target;
+    }
+    function Select(select: Omit<Select, 'type'>): Query.Select;
+    interface Update extends QueryBase {
+        type: QueryType.Update;
+        table: Schema;
+        set?: Record<string, any>;
+    }
+    function Update(update: Omit<Update, 'type'>): Query.Update;
+    interface Delete extends QueryBase {
+        type: QueryType.Delete;
+        table: Schema;
+    }
+    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
+    interface CreateTable extends QueryBase {
+        type: QueryType.CreateTable;
+        table: Schema;
+        ifNotExists?: boolean;
+    }
+    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
+    interface CreateIndex extends QueryBase {
+        type: QueryType.CreateIndex;
+        table: Schema;
+        index: Index;
+        ifNotExists?: boolean;
+    }
+    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
+    interface DropIndex extends QueryBase {
+        type: QueryType.DropIndex;
+        table: Schema;
+        name: string;
+        ifExists?: boolean;
+    }
+    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
+    interface Batch extends QueryBase {
+        type: QueryType.Batch;
+        queries: Array<Query<any>>;
+    }
+    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
+    enum TransactionOperation {
+        Begin = "Begin",
+        Commit = "Commit",
+        Rollback = "Rollback"
+    }
+    interface Transaction extends QueryBase {
+        type: QueryType.Transaction;
+        id: string;
+        op: TransactionOperation;
+    }
+    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
+    type RawReturn = 'row' | 'rows' | undefined;
+    interface Raw extends QueryBase {
+        type: QueryType.Raw;
+        expectedReturn?: 'row' | 'rows';
+        strings: ReadonlyArray<string>;
+        params: Array<any>;
+    }
+    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
+    interface AlterTable extends QueryBase {
+        type: QueryType.AlterTable;
+        table: Schema;
+        alterColumn?: ColumnData;
+        addColumn?: ColumnData;
+        dropColumn?: string;
+    }
+    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
+}

package/dist/Sanitizer.d.ts

@@ -1,4 +1,4 @@
-export interface Sanitizer {
-    escapeValue(value: any): string;
-    escapeIdentifier(ident: string): string;
-}
+export interface Sanitizer {
+    escapeValue(value: any): string;
+    escapeIdentifier(ident: string): string;
+}

package/dist/Schema.d.ts

@@ -1,23 +1,23 @@
-import { ColumnData } from './Column';
-import { ExprData } from './Expr';
-import { Formatter } from './Formatter';
-import { Query } from './Query';
-export interface Index {
-    name: string;
-    on: Array<ExprData>;
-    where?: ExprData;
-}
-export interface Schema {
-    name: string;
-    alias?: string;
-    columns: Record<string, ColumnData>;
-    indexes: Record<string, Index>;
-}
-export interface SchemaInstructions {
-    columns: Record<string, string>;
-    indexes: Record<string, string>;
-}
-export declare namespace Schema {
-    function create(schema: Schema): Query.Batch;
-    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
-}
+import { ColumnData } from './Column';
+import { ExprData } from './Expr';
+import { Formatter } from './Formatter';
+import { Query } from './Query';
+export interface Index {
+    name: string;
+    on: Array<ExprData>;
+    where?: ExprData;
+}
+export interface Schema {
+    name: string;
+    alias?: string;
+    columns: Record<string, ColumnData>;
+    indexes: Record<string, Index>;
+}
+export interface SchemaInstructions {
+    columns: Record<string, string>;
+    indexes: Record<string, string>;
+}
+export declare namespace Schema {
+    function create(schema: Schema): Query.Batch;
+    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
+}

package/dist/Selection.d.ts

@@ -1,20 +1,20 @@
-import type { Cursor } from './Cursor';
-import type { Expr } from './Expr';
-type SelectionBase = Expr<any> | Cursor.SelectMultiple<any> | Cursor.SelectSingle<any>;
-interface SelectionRecord extends Record<string, Selection> {
-}
-export type Selection = SelectionBase | SelectionRecord;
-export declare namespace Selection {
-    const __tableType: unique symbol;
-    const __cursorType: unique symbol;
-    type Infer<T> = T extends {
-        [__tableType](): infer K;
-    } ? K : T extends {
-        [__cursorType](): infer K;
-    } ? K : T extends Expr<infer K> ? K : T extends Record<string, Selection> ? {
-        [K in keyof T]: Infer<T[K]>;
-    } : T;
-    type With<A, B> = Expr<Combine<A, B>>;
-    type Combine<A, B> = Omit<A, keyof Infer<B>> & Infer<B>;
-}
-export {};
+import type { Cursor } from './Cursor';
+import type { Expr } from './Expr';
+type SelectionBase = Expr<any> | Cursor.SelectMultiple<any> | Cursor.SelectSingle<any>;
+interface SelectionRecord extends Record<string, Selection> {
+}
+export type Selection = SelectionBase | SelectionRecord;
+export declare namespace Selection {
+    const __tableType: unique symbol;
+    const __cursorType: unique symbol;
+    type Infer<T> = T extends {
+        [__tableType](): infer K;
+    } ? K : T extends {
+        [__cursorType](): infer K;
+    } ? K : T extends Expr<infer K> ? K : T extends Record<string, Selection> ? {
+        [K in keyof T]: Infer<T[K]>;
+    } : T;
+    type With<A, B> = Expr<Combine<A, B>>;
+    type Combine<A, B> = Omit<A, keyof Infer<B>> & Infer<B>;
+}
+export {};

package/dist/Statement.d.ts

@@ -1,57 +1,57 @@
-import { Sanitizer } from './Sanitizer';
-declare enum TokenType {
-    Raw = "Raw",
-    Identifier = "Identifier",
-    Value = "Value",
-    Indent = "Indent",
-    Dedent = "Dedent"
-}
-declare class Token {
-    type: TokenType;
-    data: any;
-    constructor(type: TokenType, data: any);
-    static Raw(data: string): Token;
-    static Indent(): Token;
-    static Dedent(): Token;
-    static Identifier(data: string): Token;
-    static Value(data: any): Token;
-}
-export declare class Statement {
-    tokens: Array<Token>;
-    constructor(tokens: Array<Token>);
-    concat(...tokens: Array<Token | Statement>): Statement;
-    static create(from: string | Statement): Statement;
-    static tag(strings: ReadonlyArray<string>, ...params: Array<any>): Statement;
-    space(): Statement;
-    call(method: string, ...args: Array<Statement>): Statement;
-    addCall(method: string, ...args: Array<Statement>): Statement;
-    add(addition: undefined | string | Statement): Statement;
-    addLine(addition: undefined | string | Statement): Statement;
-    addIf(condition: any, addition: string | Statement | (() => string | Statement)): Statement;
-    indent(): Statement;
-    dedent(): Statement;
-    newline(): Statement;
-    identifier(name: string): Statement;
-    addIdentifier(name: string): Statement;
-    value(value: any): Statement;
-    addValue(value: any): Statement;
-    raw(query: string): Statement;
-    parenthesis(inner: string | Statement): Statement;
-    addParenthesis(stmnt: string | Statement): Statement;
-    separated(input: Array<Statement>, separator?: string): Statement;
-    addSeparated(input: Array<Statement>, separator?: string): Statement;
-    isEmpty(): boolean;
-    compile(sanitizer: Sanitizer, formatInline?: boolean): Statement.Compiled;
-}
-export declare namespace Statement {
-    type Compiled = [sql: string, params: Array<any>];
-}
-export declare function newline(): Statement;
-export declare function raw(raw: string): Statement;
-export declare function identifier(name: string): Statement;
-export declare function value(value: any): Statement;
-export declare function empty(): Statement;
-export declare function parenthesis(stmnt: Statement): Statement;
-export declare function call(method: string, ...args: Array<Statement>): Statement;
-export declare function separated(input: Array<Statement>, separator?: string): Statement;
-export {};
+import { Sanitizer } from './Sanitizer';
+declare enum TokenType {
+    Raw = "Raw",
+    Identifier = "Identifier",
+    Value = "Value",
+    Indent = "Indent",
+    Dedent = "Dedent"
+}
+declare class Token {
+    type: TokenType;
+    data: any;
+    constructor(type: TokenType, data: any);
+    static Raw(data: string): Token;
+    static Indent(): Token;
+    static Dedent(): Token;
+    static Identifier(data: string): Token;
+    static Value(data: any): Token;
+}
+export declare class Statement {
+    tokens: Array<Token>;
+    constructor(tokens: Array<Token>);
+    concat(...tokens: Array<Token | Statement>): Statement;
+    static create(from: string | Statement): Statement;
+    static tag(strings: ReadonlyArray<string>, ...params: Array<any>): Statement;
+    space(): Statement;
+    call(method: string, ...args: Array<Statement>): Statement;
+    addCall(method: string, ...args: Array<Statement>): Statement;
+    add(addition: undefined | string | Statement): Statement;
+    addLine(addition: undefined | string | Statement): Statement;
+    addIf(condition: any, addition: string | Statement | (() => string | Statement)): Statement;
+    indent(): Statement;
+    dedent(): Statement;
+    newline(): Statement;
+    identifier(name: string): Statement;
+    addIdentifier(name: string): Statement;
+    value(value: any): Statement;
+    addValue(value: any): Statement;
+    raw(query: string): Statement;
+    parenthesis(inner: string | Statement): Statement;
+    addParenthesis(stmnt: string | Statement): Statement;
+    separated(input: Array<Statement>, separator?: string): Statement;
+    addSeparated(input: Array<Statement>, separator?: string): Statement;
+    isEmpty(): boolean;
+    compile(sanitizer: Sanitizer, formatInline?: boolean): Statement.Compiled;
+}
+export declare namespace Statement {
+    type Compiled = [sql: string, params: Array<any>];
+}
+export declare function newline(): Statement;
+export declare function raw(raw: string): Statement;
+export declare function identifier(name: string): Statement;
+export declare function value(value: any): Statement;
+export declare function empty(): Statement;
+export declare function parenthesis(stmnt: Statement): Statement;
+export declare function call(method: string, ...args: Array<Statement>): Statement;
+export declare function separated(input: Array<Statement>, separator?: string): Statement;
+export {};

package/dist/Table.d.ts

@@ -1,50 +1,56 @@
-import { Column } from './Column';
-import { Cursor } from './Cursor';
-import { Expr } from './Expr';
-import { Fields } from './Fields';
-import { Schema } from './Schema';
-import { Selection } from './Selection';
-import { Update } from './Update';
-export declare class Table<T> extends Cursor.SelectMultiple<T> {
-    [Selection.__tableType](): T;
-    constructor(schema: Schema);
-    insertOne(record: Table.Insert<T>): Cursor.Batch<T>;
-    insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
-    set(data: Update<T>): Cursor.Update<T>;
-    createTable(): Cursor.Create;
-    as(alias: string): Table<T> & Fields<T>;
-    get(name: string): Expr<any>;
-    toExpr(): Expr<T>;
-    schema(): Schema;
-}
-export declare namespace Table {
-    type Intersection<A, B> = A & B extends infer U ? {
-        [P in keyof U]: U[P];
-    } : never;
-    type OptionalKeys<T> = {
-        [K in keyof T]: null extends T[K] ? K : T[K] extends Column.Optional ? K : never;
-    }[keyof T];
-    type RequiredKeys<T> = {
-        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.Optional ? never : K;
-    }[keyof T];
-    type Optionals<T> = {
-        [K in keyof T]?: T[K] extends Column.Optional & infer V ? V : T[K];
-    };
-    export type Insert<T> = Intersection<Optionals<Pick<T, OptionalKeys<T>>>, Pick<T, RequiredKeys<T>>>;
-    export {};
-}
-export interface TableOptions<T> {
-    name: string;
-    alias?: string;
-    columns: {
-        [K in keyof T]: Column<T[K]>;
-    };
-    indexes?: (this: Fields<T>) => Record<string, {
-        on: Array<Expr<any>>;
-        where?: Expr<boolean>;
-    }>;
-}
-export declare function table<T extends {}>(options: TableOptions<T>): Table<T> & Fields<T>;
-export declare namespace table {
-    type infer<T> = T extends Table<infer U> ? U : never;
-}
+import { Column } from './Column';
+import { Cursor } from './Cursor';
+import { Expr } from './Expr';
+import { Fields } from './Fields';
+import { Schema } from './Schema';
+import { Selection } from './Selection';
+import { Update } from './Update';
+export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>> {
+    [Selection.__tableType](): Table.Normalize<T>;
+    constructor(schema: Schema);
+    insertOne(record: Table.Insert<T>): Cursor.Batch<Table.Normalize<T>>;
+    insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
+    set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;
+    createTable(): Cursor.Create;
+    as(alias: string): Table<T> & Fields<T>;
+    get(name: string): Expr<any>;
+    toExpr(): Expr<Table.Normalize<T>>;
+    schema(): Schema;
+}
+export declare namespace Table {
+    type Intersection<A, B> = A & B extends infer U ? {
+        [P in keyof U]: U[P];
+    } : never;
+    type OptionalKeys<T> = {
+        [K in keyof T]: null extends T[K] ? K : T[K] extends Column.Primary<any, any> ? K : T[K] extends Column.Optional<any> ? K : never;
+    }[keyof T];
+    type RequiredKeys<T> = {
+        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.Primary<any, any> ? never : T[K] extends Column.Optional<any> ? never : K;
+    }[keyof T];
+    type Optionals<T> = {
+        [K in keyof T]?: T[K] extends Column.Optional<infer V> ? V : T[K];
+    };
+    export type Insert<T> = Intersection<Optionals<Pick<T, OptionalKeys<T>>>, Pick<T, RequiredKeys<T>>>;
+    export type Normalize<T> = {
+        [K in keyof T]: T[K] extends Column.Optional<infer V> ? V : T[K] extends Column.Primary<infer K, infer V> ? string extends K ? V : V & {
+            [Column.isPrimary]: K;
+        } : T[K];
+    };
+    export type Infer<T> = T extends Table<infer U> ? Normalize<U> : never;
+    export {};
+}
+export interface TableOptions<T> {
+    name: string;
+    alias?: string;
+    columns: {
+        [K in keyof T]: Column<T[K]>;
+    };
+    indexes?: (this: Fields<T>) => Record<string, {
+        on: Array<Expr<any>>;
+        where?: Expr<boolean>;
+    }>;
+}
+export declare function table<T extends {}>(options: TableOptions<T>): Table<T> & Fields<T>;
+export declare namespace table {
+    type infer<T> = Table.Infer<T>;
+}

package/dist/Table.js

@@ -62,7 +62,9 @@ var Table = class extends Cursor.SelectMultiple {
     return new Expr(ExprData.Field(this.toExpr().expr, name));
   }
   toExpr() {
-    return new Expr(ExprData.Row(Target.Table(this.schema())));
+    return new Expr(
+      ExprData.Row(Target.Table(this.schema()))
+    );
   }
   schema() {
     throw new Error("Not implemented");

package/dist/Target.d.ts

@@ -1,30 +1,30 @@
-import { ExprData } from './Expr';
-import { Schema } from './Schema';
-export declare enum TargetType {
-    Each = "Each",
-    Table = "Table",
-    Join = "Join"
-}
-export type Target = Target.Each | Target.Table | Target.Join;
-export declare namespace Target {
-    interface Each {
-        type: TargetType.Each;
-        expr: ExprData;
-        alias: string;
-    }
-    function Each(expr: ExprData, alias: string): Each;
-    interface Table {
-        type: TargetType.Table;
-        table: Schema;
-    }
-    function Table(table: Schema): Table;
-    interface Join {
-        type: TargetType.Join;
-        left: Target;
-        right: Target;
-        joinType: 'left' | 'inner';
-        on: ExprData;
-    }
-    function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
-    function source(from: Target): Schema | undefined;
-}
+import { ExprData } from './Expr';
+import { Schema } from './Schema';
+export declare enum TargetType {
+    Each = "Each",
+    Table = "Table",
+    Join = "Join"
+}
+export type Target = Target.Each | Target.Table | Target.Join;
+export declare namespace Target {
+    interface Each {
+        type: TargetType.Each;
+        expr: ExprData;
+        alias: string;
+    }
+    function Each(expr: ExprData, alias: string): Each;
+    interface Table {
+        type: TargetType.Table;
+        table: Schema;
+    }
+    function Table(table: Schema): Table;
+    interface Join {
+        type: TargetType.Join;
+        left: Target;
+        right: Target;
+        joinType: 'left' | 'inner';
+        on: ExprData;
+    }
+    function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
+    function source(from: Target): Schema | undefined;
+}

package/dist/Update.d.ts

@@ -1,4 +1,4 @@
-import type { EV } from './Expr';
-export type Update<Row> = Partial<{
-    [K in keyof Row]: EV<Row[K]>;
-}>;
+import type { EV } from './Expr';
+export type Update<Row> = Partial<{
+    [K in keyof Row]: EV<Row[K]>;
+}>;

package/dist/driver/better-sqlite3.d.ts

@@ -1,17 +1,17 @@
-import type { Database } from 'better-sqlite3';
-import { Driver } from '../Driver';
-import { SchemaInstructions } from '../Schema';
-import { Statement } from '../Statement';
-export declare class BetterSqlite3Driver extends Driver.Sync {
-    db: Database;
-    constructor(db: Database);
-    rows<T extends object = object>([sql, params]: Statement.Compiled): Array<T>;
-    values([sql, params]: Statement.Compiled): Array<Array<any>>;
-    execute([sql, params]: Statement.Compiled): void;
-    mutate([sql, params]: Statement.Compiled): {
-        rowsAffected: number;
-    };
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database): BetterSqlite3Driver;
+import type { Database } from 'better-sqlite3';
+import { Driver } from '../Driver';
+import { SchemaInstructions } from '../Schema';
+import { Statement } from '../Statement';
+export declare class BetterSqlite3Driver extends Driver.Sync {
+    db: Database;
+    constructor(db: Database);
+    rows<T extends object = object>([sql, params]: Statement.Compiled): Array<T>;
+    values([sql, params]: Statement.Compiled): Array<Array<any>>;
+    execute([sql, params]: Statement.Compiled): void;
+    mutate([sql, params]: Statement.Compiled): {
+        rowsAffected: number;
+    };
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    export(): Uint8Array;
+}
+export declare function connect(db: Database): BetterSqlite3Driver;