rado 0.1.53 → 0.1.54

package/dist/driver/bun-sqlite.d.ts

@@ -1,18 +1,18 @@
-/// <reference types="bun-types" />
-import type { Database } from 'bun:sqlite';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
-export declare class BunSqliteDriver extends Driver.Sync {
-    db: Database;
-    tableData: (tableName: string) => Array<SqliteSchema.Column>;
-    indexData: (tableName: string) => Array<SqliteSchema.Index>;
-    lastChanges: () => {
-        rowsAffected: number;
-    };
-    constructor(db: Database);
-    prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-}
-export declare function connect(db: Database): BunSqliteDriver;
+/// <reference types="bun-types" />
+import type { Database } from 'bun:sqlite';
+import { SchemaInstructions } from '../define/Schema';
+import { Driver } from '../lib/Driver';
+import { Statement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
+export declare class BunSqliteDriver extends Driver.Sync {
+    db: Database;
+    tableData: (tableName: string) => Array<SqliteSchema.Column>;
+    indexData: (tableName: string) => Array<SqliteSchema.Index>;
+    lastChanges: () => {
+        rowsAffected: number;
+    };
+    constructor(db: Database);
+    prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+}
+export declare function connect(db: Database): BunSqliteDriver;

package/dist/driver/sql.js.d.ts

@@ -1,15 +1,15 @@
-import type { Database } from 'sql.js';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
-export declare class SqlJsDriver extends Driver.Sync {
-    db: Database;
-    tableData: (tableName: string) => Array<SqliteSchema.Column>;
-    indexData: (tableName: string) => Array<SqliteSchema.Index>;
-    constructor(db: Database);
-    prepareStatement(stmt: Statement, discardAfter: boolean): Driver.Sync.PreparedStatement;
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database): SqlJsDriver;
+import type { Database } from 'sql.js';
+import { SchemaInstructions } from '../define/Schema';
+import { Driver } from '../lib/Driver';
+import { Statement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
+export declare class SqlJsDriver extends Driver.Sync {
+    db: Database;
+    tableData: (tableName: string) => Array<SqliteSchema.Column>;
+    indexData: (tableName: string) => Array<SqliteSchema.Index>;
+    constructor(db: Database);
+    prepareStatement(stmt: Statement, discardAfter: boolean): Driver.Sync.PreparedStatement;
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    export(): Uint8Array;
+}
+export declare function connect(db: Database): SqlJsDriver;

package/dist/driver/sqlite3.d.ts

@@ -1,18 +1,18 @@
-import type { Database } from 'sqlite3';
-import { Query } from '../define/Query';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
-export declare class Sqlite3Driver extends Driver.Async {
-    private db;
-    lock: Promise<void> | undefined;
-    tableData: (tableName: string) => Promise<Array<SqliteSchema.Column>>;
-    indexData: (tableName: string) => Promise<Array<SqliteSchema.Index>>;
-    constructor(db: Database);
-    executeQuery<T>(query: Query<T>, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<T>;
-    prepareStatement(stmt: Statement): Driver.Async.PreparedStatement;
-    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: Driver.Async, release: () => Promise<void>];
-}
-export declare function connect(db: Database): Sqlite3Driver;
+import type { Database } from 'sqlite3';
+import { Query } from '../define/Query';
+import { SchemaInstructions } from '../define/Schema';
+import { Driver } from '../lib/Driver';
+import { Statement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
+export declare class Sqlite3Driver extends Driver.Async {
+    private db;
+    lock: Promise<void> | undefined;
+    tableData: (tableName: string) => Promise<Array<SqliteSchema.Column>>;
+    indexData: (tableName: string) => Promise<Array<SqliteSchema.Index>>;
+    constructor(db: Database);
+    executeQuery<T>(query: Query<T>, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<T>;
+    prepareStatement(stmt: Statement): Driver.Async.PreparedStatement;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: Driver.Async, release: () => Promise<void>];
+}
+export declare function connect(db: Database): Sqlite3Driver;

package/dist/index.d.ts

@@ -1,21 +1,21 @@
-export * from './define/Column';
-export * from './define/Cursor';
-export * from './define/Expr';
-export * from './define/Fields';
-export * from './define/Functions';
-export * from './define/Id';
-export * from './define/Index';
-export * from './define/Ops';
-export * from './define/OrderBy';
-export * from './define/Param';
-export * from './define/Query';
-export * from './define/Schema';
-export * from './define/Selection';
-export * from './define/Table';
-export * from './define/Target';
-export * from './define/Update';
-export type { Driver } from './lib/Driver';
-export type { FormatContext, Formatter } from './lib/Formatter';
-export type { Sanitizer } from './lib/Sanitizer';
-export * from './lib/SqlError';
-export type { Statement } from './lib/Statement';
+export * from './define/Column';
+export * from './define/Cursor';
+export * from './define/Expr';
+export * from './define/Fields';
+export * from './define/Functions';
+export * from './define/Id';
+export * from './define/Index';
+export * from './define/Ops';
+export * from './define/OrderBy';
+export * from './define/Param';
+export * from './define/Query';
+export * from './define/Schema';
+export * from './define/Selection';
+export * from './define/Table';
+export * from './define/Target';
+export * from './define/Update';
+export type { Driver } from './lib/Driver';
+export type { FormatContext, Formatter } from './lib/Formatter';
+export type { Sanitizer } from './lib/Sanitizer';
+export * from './lib/SqlError';
+export type { Statement } from './lib/Statement';

package/dist/lib/Driver.d.ts

@@ -1,110 +1,110 @@
-import { Cursor } from '../define/Cursor';
-import { Expr } from '../define/Expr';
-import { Query } from '../define/Query';
-import { SchemaInstructions } from '../define/Schema';
-import { Table } from '../define/Table';
-import { Formatter } from './Formatter';
-import { Statement } from './Statement';
-declare class Callable extends Function {
-    constructor(fn: Function);
-}
-declare abstract class DriverBase extends Callable {
-    formatter: Formatter;
-    constructor(formatter: Formatter);
-    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, Statement];
-    all(...args: Array<any>): any;
-    get(...args: Array<any>): any;
-    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
-    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
-    abstract executeQuery(query: Query<any>): any;
-}
-type ParamTypes<Params extends [...any[]]> = {
-    [K in keyof Params]: Params[K] extends Expr<infer T> ? T : never;
-} & {
-    length: Params['length'];
-};
-interface SyncDriver {
-    <T>(query: Cursor<T>): T;
-    <T>(...queries: Array<Cursor<any>>): T;
-    (strings: TemplateStringsArray, ...values: any[]): any;
-}
-declare abstract class SyncDriver extends DriverBase {
-    transactionId: number;
-    abstract prepareStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
-    abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => R;
-    migrateSchema(...tables: Array<Table<any>>): unknown;
-    executeQuery<T>(query: Query<T>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
-    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
-    all<T>(cursor: Cursor<T>): T;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-    get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
-    get<T>(cursor: Cursor<T>): T;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
-    iterate<T>(cursor: Cursor.SelectMultiple<T>): Iterable<T>;
-    transaction<T>(run: (query: SyncDriver) => T): T;
-    toAsync(): SyncWrapper;
-}
-interface SyncPreparedStatement {
-    run(params?: Array<any>): {
-        rowsAffected: number;
-    };
-    iterate<T>(params?: Array<any>): Iterable<T>;
-    all<T>(params?: Array<any>): Array<T>;
-    get<T>(params?: Array<any>): T;
-    execute(params?: Array<any>): void;
-}
-interface AsyncDriver {
-    <T>(query: Cursor<T>): Promise<T>;
-    <T>(...queries: Array<Cursor<any>>): Promise<T>;
-    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
-}
-declare abstract class AsyncDriver extends DriverBase {
-    transactionId: number;
-    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-    abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
-    abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => Promise<R>;
-    migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
-    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
-    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
-    all<T>(cursor: Cursor<T>): Promise<T>;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
-    get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
-    get<T>(cursor: Cursor<T>): Promise<T>;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
-    iterate<T>(cursor: Cursor.SelectMultiple<T>): AsyncIterable<T>;
-    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
-}
-declare class SyncWrapper extends AsyncDriver {
-    private sync;
-    lock: Promise<void> | undefined;
-    constructor(sync: SyncDriver);
-    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
-    prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
-    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-}
-interface AsyncPreparedStatement {
-    run(params?: Array<any>): Promise<{
-        rowsAffected: number;
-    }>;
-    iterate<T>(params?: Array<any>): AsyncIterable<T>;
-    all<T>(params?: Array<any>): Promise<Array<T>>;
-    get<T>(params?: Array<any>): Promise<T>;
-    execute(params?: Array<any>): Promise<void>;
-}
-export type Driver = SyncDriver | AsyncDriver;
-export declare namespace Driver {
-    type Sync = SyncDriver;
-    const Sync: typeof SyncDriver;
-    namespace Sync {
-        type PreparedStatement = SyncPreparedStatement;
-    }
-    type Async = AsyncDriver;
-    const Async: typeof AsyncDriver;
-    namespace Async {
-        type PreparedStatement = AsyncPreparedStatement;
-    }
-}
-export {};
+import { Cursor } from '../define/Cursor';
+import { Expr } from '../define/Expr';
+import { Query } from '../define/Query';
+import { SchemaInstructions } from '../define/Schema';
+import { Table } from '../define/Table';
+import { Formatter } from './Formatter';
+import { Statement } from './Statement';
+declare class Callable extends Function {
+    constructor(fn: Function);
+}
+declare abstract class DriverBase extends Callable {
+    formatter: Formatter;
+    constructor(formatter: Formatter);
+    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, Statement];
+    all(...args: Array<any>): any;
+    get(...args: Array<any>): any;
+    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
+    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
+    abstract executeQuery(query: Query<any>): any;
+}
+type ParamTypes<Params extends [...any[]]> = {
+    [K in keyof Params]: Params[K] extends Expr<infer T> ? T : never;
+} & {
+    length: Params['length'];
+};
+interface SyncDriver {
+    <T>(query: Cursor<T>): T;
+    <T>(...queries: Array<Cursor<any>>): T;
+    (strings: TemplateStringsArray, ...values: any[]): any;
+}
+declare abstract class SyncDriver extends DriverBase {
+    transactionId: number;
+    abstract prepareStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
+    abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => R;
+    migrateSchema(...tables: Array<Table<any>>): unknown;
+    executeQuery<T>(query: Query<T>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
+    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
+    all<T>(cursor: Cursor<T>): T;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
+    get<T>(cursor: Cursor<T>): T;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
+    iterate<T>(cursor: Cursor.SelectMultiple<T>): Iterable<T>;
+    transaction<T>(run: (query: SyncDriver) => T): T;
+    toAsync(): SyncWrapper;
+}
+interface SyncPreparedStatement {
+    run(params?: Array<any>): {
+        rowsAffected: number;
+    };
+    iterate<T>(params?: Array<any>): Iterable<T>;
+    all<T>(params?: Array<any>): Array<T>;
+    get<T>(params?: Array<any>): T;
+    execute(params?: Array<any>): void;
+}
+interface AsyncDriver {
+    <T>(query: Cursor<T>): Promise<T>;
+    <T>(...queries: Array<Cursor<any>>): Promise<T>;
+    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
+}
+declare abstract class AsyncDriver extends DriverBase {
+    transactionId: number;
+    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+    abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
+    abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => Promise<R>;
+    migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
+    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
+    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
+    all<T>(cursor: Cursor<T>): Promise<T>;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
+    get<T>(cursor: Cursor<T>): Promise<T>;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
+    iterate<T>(cursor: Cursor.SelectMultiple<T>): AsyncIterable<T>;
+    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
+}
+declare class SyncWrapper extends AsyncDriver {
+    private sync;
+    lock: Promise<void> | undefined;
+    constructor(sync: SyncDriver);
+    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
+    prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+}
+interface AsyncPreparedStatement {
+    run(params?: Array<any>): Promise<{
+        rowsAffected: number;
+    }>;
+    iterate<T>(params?: Array<any>): AsyncIterable<T>;
+    all<T>(params?: Array<any>): Promise<Array<T>>;
+    get<T>(params?: Array<any>): Promise<T>;
+    execute(params?: Array<any>): Promise<void>;
+}
+export type Driver = SyncDriver | AsyncDriver;
+export declare namespace Driver {
+    type Sync = SyncDriver;
+    const Sync: typeof SyncDriver;
+    namespace Sync {
+        type PreparedStatement = SyncPreparedStatement;
+    }
+    type Async = AsyncDriver;
+    const Async: typeof AsyncDriver;
+    namespace Async {
+        type PreparedStatement = AsyncPreparedStatement;
+    }
+}
+export {};

package/dist/lib/Formatter.d.ts

@@ -1,78 +1,78 @@
-import { ColumnData, ColumnType } from '../define/Column';
-import { ExprData } from '../define/Expr';
-import { OrderBy } from '../define/OrderBy';
-import { Query } from '../define/Query';
-import { Target } from '../define/Target';
-import { Sanitizer } from './Sanitizer';
-import { Statement, StatementOptions } from './Statement';
-export interface FormatContext {
-    stmt: Statement;
-    nameResult?: string;
-    /** Skip prefixing fields with their table name */
-    skipTableName?: boolean;
-    /**
-     * In SQLite table names are used as expressions in the FTS5 plugin.
-     * To distinguish between formatting a row of the table and just the table name
-     * this flag can be used.
-     **/
-    tableAsExpr?: boolean;
-    /** Inline all parameters */
-    forceInline?: boolean;
-    formatAsJson?: boolean;
-    formatAsDefault?: boolean;
-    topLevel?: boolean;
-}
-type FormatSubject = (stmt: Statement, mkSubject: () => void) => void;
-export declare abstract class Formatter implements Sanitizer {
-    constructor();
-    abstract escapeValue(value: any): string;
-    abstract escapeIdentifier(ident: string): string;
-    abstract formatParamValue(paramValue: any): any;
-    abstract formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
-    compile<T>(query: Query<T>, options?: Partial<FormatContext>): Statement;
-    createContext(options?: Partial<FormatContext> & StatementOptions): {
-        stmt: Statement;
-        nameResult?: string | undefined;
-        skipTableName?: boolean | undefined;
-        tableAsExpr?: boolean | undefined;
-        forceInline?: boolean | undefined;
-        formatAsJson?: boolean | undefined;
-        formatAsDefault?: boolean | undefined;
-        topLevel?: boolean | undefined;
-        skipNewlines?: boolean | undefined;
-    };
-    format<T>(ctx: FormatContext, query: Query<T>): Statement;
-    formatSelect(ctx: FormatContext, query: Query.Select): Statement;
-    formatInsert(ctx: FormatContext, query: Query.Insert): Statement;
-    formatUpdate(ctx: FormatContext, query: Query.Update): Statement;
-    formatDelete(ctx: FormatContext, query: Query.Delete): Statement;
-    formatCreateTable(ctx: FormatContext, query: Query.CreateTable): Statement;
-    formatCreateIndex(ctx: FormatContext, query: Query.CreateIndex): Statement;
-    formatDropIndex(ctx: FormatContext, query: Query.DropIndex): Statement;
-    formatAlterTable(ctx: FormatContext, query: Query.AlterTable): Statement;
-    formatTransaction(ctx: FormatContext, { op, id }: Query.Transaction): Statement;
-    formatBatch(ctx: FormatContext, { queries }: Query.Batch): Statement;
-    formatRaw(ctx: FormatContext, { strings, params }: Query.Raw): Statement;
-    formatColumn(ctx: FormatContext, column: ColumnData): Statement;
-    formatContraintReference(ctx: FormatContext, reference: ExprData): Statement;
-    formatType(ctx: FormatContext, type: ColumnType): Statement;
-    formatInsertRow(ctx: FormatContext, columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
-    formatColumnValue(ctx: FormatContext, column: ColumnData, columnValue: any): Statement;
-    formatTarget(ctx: FormatContext, target: Target): Statement;
-    formatWhere(ctx: FormatContext, expr: ExprData | undefined): Statement;
-    formatHaving(ctx: FormatContext, expr: ExprData | undefined): Statement;
-    formatGroupBy(ctx: FormatContext, groupBy: Array<ExprData> | undefined): Statement;
-    formatOrderBy(ctx: FormatContext, orderBy: Array<OrderBy> | undefined): Statement;
-    formatLimit(ctx: FormatContext, { limit, offset, singleResult }: Query.QueryBase): Statement;
-    formatSelection(ctx: FormatContext, selection: ExprData, formatSubject?: FormatSubject): Statement;
-    formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
-    formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
-    formatIn(ctx: FormatContext, expr: ExprData): Statement;
-    retrieveField(expr: ExprData, field: string): ExprData | undefined;
-    formatField(ctx: FormatContext, expr: ExprData, field: string): Statement;
-    formatString(ctx: FormatContext, input: string): Statement;
-    formatInlineValue(ctx: FormatContext, rawValue: any): Statement;
-    formatValue(ctx: FormatContext, rawValue: any): Statement;
-    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
-}
-export {};
+import { ColumnData, ColumnType } from '../define/Column';
+import { ExprData } from '../define/Expr';
+import { OrderBy } from '../define/OrderBy';
+import { Query } from '../define/Query';
+import { Target } from '../define/Target';
+import { Sanitizer } from './Sanitizer';
+import { Statement, StatementOptions } from './Statement';
+export interface FormatContext {
+    stmt: Statement;
+    nameResult?: string;
+    /** Skip prefixing fields with their table name */
+    skipTableName?: boolean;
+    /**
+     * In SQLite table names are used as expressions in the FTS5 plugin.
+     * To distinguish between formatting a row of the table and just the table name
+     * this flag can be used.
+     **/
+    tableAsExpr?: boolean;
+    /** Inline all parameters */
+    forceInline?: boolean;
+    formatAsJson?: boolean;
+    formatAsDefault?: boolean;
+    topLevel?: boolean;
+}
+type FormatSubject = (stmt: Statement, mkSubject: () => void) => void;
+export declare abstract class Formatter implements Sanitizer {
+    constructor();
+    abstract escapeValue(value: any): string;
+    abstract escapeIdentifier(ident: string): string;
+    abstract formatParamValue(paramValue: any): any;
+    abstract formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
+    compile<T>(query: Query<T>, options?: Partial<FormatContext>): Statement;
+    createContext(options?: Partial<FormatContext> & StatementOptions): {
+        stmt: Statement;
+        nameResult?: string | undefined;
+        skipTableName?: boolean | undefined;
+        tableAsExpr?: boolean | undefined;
+        forceInline?: boolean | undefined;
+        formatAsJson?: boolean | undefined;
+        formatAsDefault?: boolean | undefined;
+        topLevel?: boolean | undefined;
+        skipNewlines?: boolean | undefined;
+    };
+    format<T>(ctx: FormatContext, query: Query<T>): Statement;
+    formatSelect(ctx: FormatContext, query: Query.Select): Statement;
+    formatInsert(ctx: FormatContext, query: Query.Insert): Statement;
+    formatUpdate(ctx: FormatContext, query: Query.Update): Statement;
+    formatDelete(ctx: FormatContext, query: Query.Delete): Statement;
+    formatCreateTable(ctx: FormatContext, query: Query.CreateTable): Statement;
+    formatCreateIndex(ctx: FormatContext, query: Query.CreateIndex): Statement;
+    formatDropIndex(ctx: FormatContext, query: Query.DropIndex): Statement;
+    formatAlterTable(ctx: FormatContext, query: Query.AlterTable): Statement;
+    formatTransaction(ctx: FormatContext, { op, id }: Query.Transaction): Statement;
+    formatBatch(ctx: FormatContext, { queries }: Query.Batch): Statement;
+    formatRaw(ctx: FormatContext, { strings, params }: Query.Raw): Statement;
+    formatColumn(ctx: FormatContext, column: ColumnData): Statement;
+    formatContraintReference(ctx: FormatContext, reference: ExprData): Statement;
+    formatType(ctx: FormatContext, type: ColumnType): Statement;
+    formatInsertRow(ctx: FormatContext, columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
+    formatColumnValue(ctx: FormatContext, column: ColumnData, columnValue: any): Statement;
+    formatTarget(ctx: FormatContext, target: Target): Statement;
+    formatWhere(ctx: FormatContext, expr: ExprData | undefined): Statement;
+    formatHaving(ctx: FormatContext, expr: ExprData | undefined): Statement;
+    formatGroupBy(ctx: FormatContext, groupBy: Array<ExprData> | undefined): Statement;
+    formatOrderBy(ctx: FormatContext, orderBy: Array<OrderBy> | undefined): Statement;
+    formatLimit(ctx: FormatContext, { limit, offset, singleResult }: Query.QueryBase): Statement;
+    formatSelection(ctx: FormatContext, selection: ExprData, formatSubject?: FormatSubject): Statement;
+    formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
+    formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
+    formatIn(ctx: FormatContext, expr: ExprData): Statement;
+    retrieveField(expr: ExprData, field: string): ExprData | undefined;
+    formatField(ctx: FormatContext, expr: ExprData, field: string): Statement;
+    formatString(ctx: FormatContext, input: string): Statement;
+    formatInlineValue(ctx: FormatContext, rawValue: any): Statement;
+    formatValue(ctx: FormatContext, rawValue: any): Statement;
+    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
+}
+export {};

package/dist/lib/Sanitizer.d.ts

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

package/dist/lib/SqlError.d.ts

@@ -1,3 +1,3 @@
-export declare class SqlError extends Error {
-    constructor(cause: Error, sql: string);
-}
+export declare class SqlError extends Error {
+    constructor(cause: Error, sql: string);
+}

package/dist/lib/Statement.d.ts

@@ -1,33 +1,33 @@
-import { ParamData } from '../define/Param';
-import { Sanitizer } from './Sanitizer';
-export interface StatementOptions {
-    skipNewlines?: boolean;
-}
-export declare class Statement {
-    sanitizer: Sanitizer;
-    options: StatementOptions;
-    sql: string;
-    paramData: Array<ParamData>;
-    currentIndent: string;
-    constructor(sanitizer: Sanitizer, options?: StatementOptions);
-    space(): this;
-    add(addition: undefined | string): this;
-    addLine(addition: undefined | string): this;
-    indent(): this;
-    dedent(): this;
-    newline(): this;
-    identifier(name: string): this;
-    addIdentifier(name: string): this;
-    value(value: any): this;
-    addValue(value: any): this;
-    param(data: ParamData): this;
-    addParam(data: ParamData): this;
-    raw(query: string): this;
-    openParenthesis(): this;
-    closeParenthesis(): this;
-    call<T>(parts: Array<T>, separator?: string): Generator<T, this | undefined, unknown>;
-    separate<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
-    isEmpty(): boolean;
-    params(input?: Record<string, any>): Array<any>;
-    toString(): string;
-}
+import { ParamData } from '../define/Param';
+import { Sanitizer } from './Sanitizer';
+export interface StatementOptions {
+    skipNewlines?: boolean;
+}
+export declare class Statement {
+    sanitizer: Sanitizer;
+    options: StatementOptions;
+    sql: string;
+    paramData: Array<ParamData>;
+    currentIndent: string;
+    constructor(sanitizer: Sanitizer, options?: StatementOptions);
+    space(): this;
+    add(addition: undefined | string): this;
+    addLine(addition: undefined | string): this;
+    indent(): this;
+    dedent(): this;
+    newline(): this;
+    identifier(name: string): this;
+    addIdentifier(name: string): this;
+    value(value: any): this;
+    addValue(value: any): this;
+    param(data: ParamData): this;
+    addParam(data: ParamData): this;
+    raw(query: string): this;
+    openParenthesis(): this;
+    closeParenthesis(): this;
+    call<T>(parts: Array<T>, separator?: string): Generator<T, this | undefined, unknown>;
+    separate<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
+    isEmpty(): boolean;
+    params(input?: Record<string, any>): Array<any>;
+    toString(): string;
+}

package/dist/sqlite/SqliteFormatter.d.ts

@@ -1,11 +1,11 @@
-import { ExprData } from '../define/Expr';
-import { FormatContext, Formatter } from '../lib/Formatter';
-import { Statement } from '../lib/Statement';
-export declare class SqliteFormatter extends Formatter {
-    formatParamValue(paramValue: any): any;
-    escapeValue(value: any): string;
-    escapeIdentifier(input: string): string;
-    escapeString(input: string): string;
-    formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
-    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
-}
+import { ExprData } from '../define/Expr';
+import { FormatContext, Formatter } from '../lib/Formatter';
+import { Statement } from '../lib/Statement';
+export declare class SqliteFormatter extends Formatter {
+    formatParamValue(paramValue: any): any;
+    escapeValue(value: any): string;
+    escapeIdentifier(input: string): string;
+    escapeString(input: string): string;
+    formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
+    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
+}