@revojs/storage 0.1.58

package/dist/protocols/postgresql.d.ts

@@ -0,0 +1,204 @@
+import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Table, UniqueConstraint, UniqueIndex, UpdateStatement, type AppendToNullabilityMap, type AppendToSelection, type Definition, type SelectMode, type Session, type Sql } from "../index";
+export type TimestampMode = "date" | "string";
+export interface CharOptions {
+    length?: number;
+}
+export interface DateOptions<TMode = TimestampMode> {
+    mode?: TMode;
+}
+export interface DecimalOptions {
+    precision: number;
+    scale: number;
+}
+export interface NumericOptions {
+    precision: number;
+    scale: number;
+}
+export interface TimestampOptions<TMode = TimestampMode> {
+    mode?: TMode;
+    precision?: number;
+}
+export interface VarcharOptions {
+    length?: number;
+}
+export declare abstract class PostgresqlColumn<TDataType = unknown> extends Column<TDataType> {
+    generatedAlwaysAsIdentity<This extends PostgresqlColumn>(this: This): This & Record<"generatedAlwaysAsIdentity", never>;
+    type<TData>(): this & Record<"$type", TData>;
+}
+export declare class BigintColumn extends PostgresqlColumn<bigint> {
+    toSqlType(): string;
+}
+export declare class BigserialColumn extends PostgresqlColumn<number> {
+    toSqlType(): string;
+}
+export declare class BooleanColumn extends PostgresqlColumn<boolean> {
+    toSqlType(): string;
+}
+export declare class CharColumn extends PostgresqlColumn<string> {
+    protected $options: CharOptions | undefined;
+    constructor(name: string, options?: CharOptions);
+    toSqlType(): string;
+}
+export declare class CidrColumn extends PostgresqlColumn<string> {
+    toSqlType(): string;
+}
+export declare class DateColumn extends PostgresqlColumn<Date> {
+    protected $options: DateOptions | undefined;
+    constructor(name: string, options?: DateOptions);
+    toSqlType(): string;
+}
+export declare class DecimalColumn extends PostgresqlColumn<string> {
+    protected $options: DecimalOptions | undefined;
+    constructor(name: string, options?: DecimalOptions);
+    toSqlType(): string;
+}
+export declare class DoublePrecisionColumn extends PostgresqlColumn<number> {
+    toSqlType(): string;
+}
+export declare class InetColumn extends PostgresqlColumn<string> {
+    toSqlType(): string;
+}
+export declare class IntegerColumn extends PostgresqlColumn<number> {
+    toSqlType(): string;
+}
+export declare class IntervalColumn extends PostgresqlColumn<string> {
+    toSqlType(): string;
+}
+export declare class JsonColumn extends PostgresqlColumn {
+    toSqlType(): string;
+}
+export declare class JsonbColumn extends PostgresqlColumn {
+    toSqlType(): string;
+}
+export declare class LineColumn extends PostgresqlColumn {
+    toSqlType(): string;
+}
+export declare class MacaddrColumn extends PostgresqlColumn<string> {
+    toSqlType(): string;
+}
+export declare class Macaddr8Column extends PostgresqlColumn<string> {
+    toSqlType(): string;
+}
+export declare class NumericColumn extends PostgresqlColumn<string> {
+    protected $options: NumericOptions | undefined;
+    constructor(name: string, options?: NumericOptions);
+    toSqlType(): string;
+}
+export declare class EnumerationColumn extends PostgresqlColumn<string> {
+    toSqlType(): string;
+}
+export declare class PointColumn extends PostgresqlColumn {
+    toSqlType(): string;
+}
+export declare class RealColumn extends PostgresqlColumn<number> {
+    toSqlType(): string;
+}
+export declare class SerialColumn extends PostgresqlColumn<number> {
+    toSqlType(): string;
+}
+export declare class SmallintColumn extends PostgresqlColumn<number> {
+    toSqlType(): string;
+}
+export declare class SmallserialColumn extends PostgresqlColumn<number> {
+    toSqlType(): string;
+}
+export declare class TextColumn extends PostgresqlColumn<string> {
+    toSqlType(): string;
+}
+export declare class TimeColumn extends PostgresqlColumn<string> {
+    toSqlType(): string;
+}
+export declare class TimestampColumn extends PostgresqlColumn<Date> {
+    protected $options: TimestampOptions | undefined;
+    constructor(name: string, options?: TimestampOptions);
+    toSqlType(): string;
+}
+export declare class UuidColumn extends PostgresqlColumn<string> {
+    toSqlType(): string;
+}
+export declare class VarcharColumn extends PostgresqlColumn<string> {
+    protected $options: VarcharOptions | undefined;
+    constructor(name: string, options?: VarcharOptions);
+    toSqlType(): string;
+}
+export declare class PostgresqlUniqueConstraint extends UniqueConstraint {
+    nullsNotDistinct<This>(this: This): This & Record<"nullsNotDistinct", never>;
+}
+export declare class PostgresqlCheckConstraint extends CheckConstraint {
+}
+export declare class PostgresqlPrimaryKeyConstraint extends PrimaryKeyConstraint {
+}
+export declare class PostgresqlForeignKeyConstraint extends ForeignKeyConstraint {
+}
+export declare class PostgresqlIndex extends Index {
+    onOnly<This>(this: This): This & Record<"onOnly", never>;
+    using<This>(this: This): This & Record<"using", never>;
+    concurrently<This>(this: This): This & Record<"concurrently", never>;
+    where<This>(this: This): This & Record<"where", never>;
+    with<This>(this: This): This & Record<"with", never>;
+}
+export declare class PostgresqlUniqueIndex extends UniqueIndex {
+    onOnly<This>(this: This): This & Record<"onOnly", never>;
+    using<This>(this: This): This & Record<"using", never>;
+    concurrently<This>(this: This): This & Record<"concurrently", never>;
+    where<This>(this: This): This & Record<"where", never>;
+    with<This>(this: This): This & Record<"with", never>;
+}
+export declare class PostgresqlSelectStatement<TSelection = Table | Record<string, Column>, TMode extends SelectMode = TSelection extends Table ? "single" : "partial", TNullability extends Record<string, boolean> = TSelection extends Table ? Record<TSelection["$name"], false> : {}> extends SelectStatement<TSelection, TMode, TNullability> {
+    fullJoin<TTable extends Table>(table: TTable, on: Sql): PostgresqlSelectStatement<AppendToSelection<TSelection, TTable, TMode>, TMode extends "partial" ? "partial" : "multiple", AppendToNullabilityMap<TNullability, TTable, "full">>;
+}
+export declare class PostgresqlInsertStatement<T extends Table> extends InsertStatement<T> {
+}
+export declare class PostgresqlUpdateStatement<T extends Table> extends UpdateStatement<T> {
+}
+export declare class PostgresqlDeleteStatement<T extends Table> extends DeleteStatement<T> {
+}
+export declare class PostgresqlTable<TName extends string = string, TColumns extends Record<string, PostgresqlColumn> = Record<string, PostgresqlColumn>> extends Table<TName, TColumns> {
+}
+export declare class PostgresqlMigration extends Migration {
+    readonly $dialect = "postgresql";
+    protected quoteIdentifier(value: string): string;
+}
+export declare class PostgresqlDatabase<T extends Record<string, PostgresqlTable>> extends Database<T> {
+    readonly $migration: PostgresqlMigration;
+    constructor(session: Session, schema: T);
+    select<T extends Table | Record<string, Column>>(value: T): PostgresqlSelectStatement<T, T extends Table<string, Record<string, Column<unknown>>> ? "single" : "partial", T extends Table<string, Record<string, Column<unknown>>> ? Record<T["$name"], false> : {}>;
+    insert<T extends Table>(table: T): PostgresqlInsertStatement<T>;
+    update<T extends Table>(table: T): PostgresqlUpdateStatement<T>;
+    delete<T extends Table>(table: T): PostgresqlDeleteStatement<T>;
+}
+export declare function bigint(name: string): BigintColumn;
+export declare function bigserial(name: string): BigserialColumn;
+export declare function boolean(name: string): BooleanColumn;
+export declare function char(name: string, options?: CharOptions): CharColumn;
+export declare function cidr(name: string): CidrColumn;
+export declare function date(name: string, options?: DateOptions): DateColumn;
+export declare function decimal(name: string, options?: DecimalOptions): DecimalColumn;
+export declare function doublePrecision(name: string): DoublePrecisionColumn;
+export declare function inet(name: string): InetColumn;
+export declare function integer(name: string): IntegerColumn;
+export declare function interval(name: string): IntervalColumn;
+export declare function json(name: string): JsonColumn;
+export declare function jsonb(name: string): JsonbColumn;
+export declare function line(name: string): LineColumn;
+export declare function macaddr(name: string): MacaddrColumn;
+export declare function macaddr8(name: string): Macaddr8Column;
+export declare function numeric(name: string, options?: NumericOptions): NumericColumn;
+export declare function enumeration(name: string): EnumerationColumn;
+export declare function point(name: string): PointColumn;
+export declare function real(name: string): RealColumn;
+export declare function serial(name: string): SerialColumn;
+export declare function smallint(name: string): SmallintColumn;
+export declare function smallserial(name: string): SmallserialColumn;
+export declare function text(name: string): TextColumn;
+export declare function time(name: string): TimeColumn;
+export declare function timestamp(name: string, options?: TimestampOptions): TimestampColumn;
+export declare function uuid(name: string): UuidColumn;
+export declare function varchar(name: string, options?: VarcharOptions): VarcharColumn;
+export declare function unique(...columns: Array<Column>): PostgresqlUniqueConstraint;
+export declare function check(value: Sql): PostgresqlCheckConstraint;
+export declare function primaryKey(...columns: Array<Column>): PostgresqlPrimaryKeyConstraint;
+export declare function foreignKey(columns: Array<Column>, foreignColumns: Array<Column>): PostgresqlForeignKeyConstraint;
+export declare function index(...columns: Array<Column>): PostgresqlIndex;
+export declare function uniqueIndex(...columns: Array<Column>): PostgresqlUniqueIndex;
+export declare function table<TName extends string, TColumns extends Record<string, PostgresqlColumn>>(name: TName, columns: TColumns, definitions?: (columns: TColumns) => Array<Definition>): PostgresqlTable<TName, TColumns> & TColumns;

package/dist/protocols/postgresql.js

@@ -0,0 +1,373 @@
+import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Table, UniqueConstraint, UniqueIndex, UpdateStatement, combine, sql } from "../index.js";
+//#region src/protocols/postgresql.ts
+var PostgresqlColumn = class extends Column {
+	generatedAlwaysAsIdentity() {
+		return this;
+	}
+	type() {
+		return this;
+	}
+};
+var BigintColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "bigint";
+	}
+};
+var BigserialColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "bigserial";
+	}
+};
+var BooleanColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "boolean";
+	}
+};
+var CharColumn = class extends PostgresqlColumn {
+	$options;
+	constructor(name, options) {
+		super(name);
+		this.$options = options;
+	}
+	toSqlType() {
+		return this.$options?.length === void 0 ? "char" : `char(${this.$options.length})`;
+	}
+};
+var CidrColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "cidr";
+	}
+};
+var DateColumn = class extends PostgresqlColumn {
+	$options;
+	constructor(name, options) {
+		super(name);
+		this.$options = options;
+	}
+	toSqlType() {
+		return "date";
+	}
+};
+var DecimalColumn = class extends PostgresqlColumn {
+	$options;
+	constructor(name, options) {
+		super(name);
+		this.$options = options;
+	}
+	toSqlType() {
+		return this.$options === void 0 ? "numeric" : `numeric(${this.$options.precision}, ${this.$options.scale})`;
+	}
+};
+var DoublePrecisionColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "double precision";
+	}
+};
+var InetColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "inet";
+	}
+};
+var IntegerColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "integer";
+	}
+};
+var IntervalColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "interval";
+	}
+};
+var JsonColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "json";
+	}
+};
+var JsonbColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "jsonb";
+	}
+};
+var LineColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "line";
+	}
+};
+var MacaddrColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "macaddr";
+	}
+};
+var Macaddr8Column = class extends PostgresqlColumn {
+	toSqlType() {
+		return "macaddr8";
+	}
+};
+var NumericColumn = class extends PostgresqlColumn {
+	$options;
+	constructor(name, options) {
+		super(name);
+		this.$options = options;
+	}
+	toSqlType() {
+		return this.$options === void 0 ? "numeric" : `numeric(${this.$options.precision}, ${this.$options.scale})`;
+	}
+};
+var EnumerationColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "enum";
+	}
+};
+var PointColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "point";
+	}
+};
+var RealColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "real";
+	}
+};
+var SerialColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "serial";
+	}
+};
+var SmallintColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "smallint";
+	}
+};
+var SmallserialColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "smallserial";
+	}
+};
+var TextColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "text";
+	}
+};
+var TimeColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "time";
+	}
+};
+var TimestampColumn = class extends PostgresqlColumn {
+	$options;
+	constructor(name, options) {
+		super(name);
+		this.$options = options;
+	}
+	toSqlType() {
+		return this.$options?.precision === void 0 ? "timestamp" : `timestamp(${this.$options.precision})`;
+	}
+};
+var UuidColumn = class extends PostgresqlColumn {
+	toSqlType() {
+		return "uuid";
+	}
+};
+var VarcharColumn = class extends PostgresqlColumn {
+	$options;
+	constructor(name, options) {
+		super(name);
+		this.$options = options;
+	}
+	toSqlType() {
+		return this.$options?.length === void 0 ? "varchar" : `varchar(${this.$options.length})`;
+	}
+};
+var PostgresqlUniqueConstraint = class extends UniqueConstraint {
+	nullsNotDistinct() {
+		return this;
+	}
+};
+var PostgresqlCheckConstraint = class extends CheckConstraint {};
+var PostgresqlPrimaryKeyConstraint = class extends PrimaryKeyConstraint {};
+var PostgresqlForeignKeyConstraint = class extends ForeignKeyConstraint {};
+var PostgresqlIndex = class extends Index {
+	onOnly() {
+		return this;
+	}
+	using() {
+		return this;
+	}
+	concurrently() {
+		return this;
+	}
+	where() {
+		return this;
+	}
+	with() {
+		return this;
+	}
+};
+var PostgresqlUniqueIndex = class extends UniqueIndex {
+	onOnly() {
+		return this;
+	}
+	using() {
+		return this;
+	}
+	concurrently() {
+		return this;
+	}
+	where() {
+		return this;
+	}
+	with() {
+		return this;
+	}
+};
+var PostgresqlSelectStatement = class extends SelectStatement {
+	fullJoin(table, on) {
+		this.push(sql`FULL JOIN ${table} ON ${on}`);
+		if (this.$value instanceof Table) {
+			this.$selection.push(", ", combine(Object.values(table.$columns), ", "));
+			this.$baseNullable = true;
+			this.$joins.forEach((join) => join.nullable = true);
+			this.$joins.push({
+				table,
+				nullable: true
+			});
+		}
+		return this;
+	}
+};
+var PostgresqlInsertStatement = class extends InsertStatement {};
+var PostgresqlUpdateStatement = class extends UpdateStatement {};
+var PostgresqlDeleteStatement = class extends DeleteStatement {};
+var PostgresqlTable = class extends Table {};
+var PostgresqlMigration = class extends Migration {
+	$dialect = "postgresql";
+	quoteIdentifier(value) {
+		return `"${value.replaceAll("\"", "\"\"")}"`;
+	}
+};
+var PostgresqlDatabase = class extends Database {
+	$migration;
+	constructor(session, schema) {
+		super(session, schema);
+		this.$migration = new PostgresqlMigration();
+	}
+	select(value) {
+		return new PostgresqlSelectStatement(this.$session, value);
+	}
+	insert(table) {
+		return new PostgresqlInsertStatement(this.$session, table);
+	}
+	update(table) {
+		return new PostgresqlUpdateStatement(this.$session, table);
+	}
+	delete(table) {
+		return new PostgresqlDeleteStatement(this.$session, table);
+	}
+};
+function bigint(name) {
+	return new BigintColumn(name);
+}
+function bigserial(name) {
+	return new BigserialColumn(name);
+}
+function boolean(name) {
+	return new BooleanColumn(name);
+}
+function char(name, options) {
+	return new CharColumn(name, options);
+}
+function cidr(name) {
+	return new CidrColumn(name);
+}
+function date(name, options) {
+	return new DateColumn(name, options);
+}
+function decimal(name, options) {
+	return new DecimalColumn(name, options);
+}
+function doublePrecision(name) {
+	return new DoublePrecisionColumn(name);
+}
+function inet(name) {
+	return new InetColumn(name);
+}
+function integer(name) {
+	return new IntegerColumn(name);
+}
+function interval(name) {
+	return new IntervalColumn(name);
+}
+function json(name) {
+	return new JsonColumn(name);
+}
+function jsonb(name) {
+	return new JsonbColumn(name);
+}
+function line(name) {
+	return new LineColumn(name);
+}
+function macaddr(name) {
+	return new MacaddrColumn(name);
+}
+function macaddr8(name) {
+	return new Macaddr8Column(name);
+}
+function numeric(name, options) {
+	return new NumericColumn(name, options);
+}
+function enumeration(name) {
+	return new EnumerationColumn(name);
+}
+function point(name) {
+	return new PointColumn(name);
+}
+function real(name) {
+	return new RealColumn(name);
+}
+function serial(name) {
+	return new SerialColumn(name);
+}
+function smallint(name) {
+	return new SmallintColumn(name);
+}
+function smallserial(name) {
+	return new SmallserialColumn(name);
+}
+function text(name) {
+	return new TextColumn(name);
+}
+function time(name) {
+	return new TimeColumn(name);
+}
+function timestamp(name, options) {
+	return new TimestampColumn(name, options);
+}
+function uuid(name) {
+	return new UuidColumn(name);
+}
+function varchar(name, options) {
+	return new VarcharColumn(name, options);
+}
+function unique(...columns) {
+	return new PostgresqlUniqueConstraint(...columns);
+}
+function check(value) {
+	return new PostgresqlCheckConstraint(value);
+}
+function primaryKey(...columns) {
+	return new PostgresqlPrimaryKeyConstraint(...columns);
+}
+function foreignKey(columns, foreignColumns) {
+	return new PostgresqlForeignKeyConstraint(columns, foreignColumns);
+}
+function index(...columns) {
+	return new PostgresqlIndex(...columns);
+}
+function uniqueIndex(...columns) {
+	return new PostgresqlUniqueIndex(...columns);
+}
+function table(name, columns, definitions) {
+	return Object.assign(new PostgresqlTable(name, columns, definitions?.(columns) ?? []), columns);
+}
+//#endregion
+export { BigintColumn, BigserialColumn, BooleanColumn, CharColumn, CidrColumn, DateColumn, DecimalColumn, DoublePrecisionColumn, EnumerationColumn, InetColumn, IntegerColumn, IntervalColumn, JsonColumn, JsonbColumn, LineColumn, Macaddr8Column, MacaddrColumn, NumericColumn, PointColumn, PostgresqlCheckConstraint, PostgresqlColumn, PostgresqlDatabase, PostgresqlDeleteStatement, PostgresqlForeignKeyConstraint, PostgresqlIndex, PostgresqlInsertStatement, PostgresqlMigration, PostgresqlPrimaryKeyConstraint, PostgresqlSelectStatement, PostgresqlTable, PostgresqlUniqueConstraint, PostgresqlUniqueIndex, PostgresqlUpdateStatement, RealColumn, SerialColumn, SmallintColumn, SmallserialColumn, TextColumn, TimeColumn, TimestampColumn, UuidColumn, VarcharColumn, bigint, bigserial, boolean, char, check, cidr, date, decimal, doublePrecision, enumeration, foreignKey, index, inet, integer, interval, json, jsonb, line, macaddr, macaddr8, numeric, point, primaryKey, real, serial, smallint, smallserial, table, text, time, timestamp, unique, uniqueIndex, uuid, varchar };

package/dist/protocols/sqlite.d.ts

@@ -0,0 +1,96 @@
+import type { Primitive } from "revojs/shared";
+import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Table, UniqueConstraint, UniqueIndex, UpdateStatement, type AppendToNullabilityMap, type AppendToSelection, type ColumnMeta, type Definition, type DeleteConstraintChange, type MigrationContext, type SelectMode, type Session, type Sql, type UpdateColumnChange } from "../index";
+export type IntegerMode = "number" | "timestamp" | "timestamp_ms" | "boolean";
+export type IntegerData<TMode> = TMode extends "timestamp" | "timestamp_ms" ? Date : TMode extends "boolean" ? boolean : number;
+export type TextMode = "text" | "json";
+export type TextData<TMode> = TMode extends "json" ? unknown : string;
+export interface IntegerOptions<TMode = IntegerMode> {
+    mode?: TMode;
+}
+export interface TextOptions<TMode = TextMode> {
+    mode?: TMode;
+}
+export interface SqliteColumnMeta<TMode extends string = string> extends ColumnMeta {
+    mode?: TMode;
+}
+export declare abstract class SqliteColumn<TDataType = unknown> extends Column<TDataType> {
+    type<TData>(): this & Record<"$type", TData>;
+}
+export declare class BlobColumn extends SqliteColumn<Uint8Array> {
+    toSqlType(): string;
+}
+export declare class IntegerColumn<TMode extends IntegerMode = "number"> extends SqliteColumn<IntegerData<TMode>> {
+    readonly $options: IntegerOptions<TMode> | undefined;
+    constructor(name: string, options?: IntegerOptions<TMode>);
+    toSqlType(): string;
+    toMeta(): SqliteColumnMeta<TMode>;
+    fromDriverValue(value: unknown): IntegerData<TMode>;
+    toDriverValue(value: IntegerData<TMode>): Primitive;
+}
+export declare class NumericColumn extends SqliteColumn<number> {
+    toSqlType(): string;
+}
+export declare class RealColumn extends SqliteColumn<number> {
+    toSqlType(): string;
+}
+export declare class TextColumn<TMode extends TextMode = "text"> extends SqliteColumn<TextData<TMode>> {
+    readonly $options: TextOptions<TMode> | undefined;
+    constructor(name: string, options?: TextOptions<TMode>);
+    toSqlType(): string;
+    toMeta(): SqliteColumnMeta<TMode>;
+    fromDriverValue(value: unknown): TextData<TMode>;
+    toDriverValue(value: TextData<TMode>): Primitive;
+}
+export declare class SqliteUniqueConstraint extends UniqueConstraint {
+}
+export declare class SqliteCheckConstraint extends CheckConstraint {
+}
+export declare class SqlitePrimaryKeyConstraint extends PrimaryKeyConstraint {
+}
+export declare class SqliteForeignKeyConstraint extends ForeignKeyConstraint {
+}
+export declare class SqliteIndex extends Index {
+    where<This>(this: This): This & Record<"where", never>;
+}
+export declare class SqliteUniqueIndex extends UniqueIndex {
+    where<This>(this: This): This & Record<"where", never>;
+}
+export declare class SqliteSelectStatement<TSelection = Table | Record<string, Column>, TMode extends SelectMode = TSelection extends Table ? "single" : "partial", TNullability extends Record<string, boolean> = TSelection extends Table ? Record<TSelection["$name"], false> : {}> extends SelectStatement<TSelection, TMode, TNullability> {
+    fullJoin<TTable extends Table>(table: TTable, on: Sql): SqliteSelectStatement<AppendToSelection<TSelection, TTable, TMode>, TMode extends "partial" ? "partial" : "multiple", AppendToNullabilityMap<TNullability, TTable, "full">>;
+}
+export declare class SqliteInsertStatement<T extends Table> extends InsertStatement<T> {
+}
+export declare class SqliteUpdateStatement<T extends Table> extends UpdateStatement<T> {
+}
+export declare class SqliteDeleteStatement<T extends Table> extends DeleteStatement<T> {
+}
+export declare class SqliteTable<TName extends string = string, TColumns extends Record<string, SqliteColumn> = Record<string, SqliteColumn>> extends Table<TName, TColumns> {
+}
+export declare class SqliteMigration extends Migration {
+    readonly $dialect = "sqlite";
+    protected render({ changes, current }: MigrationContext): string[];
+    protected toUpdateColumnChange(change: UpdateColumnChange): Array<string>;
+    protected toDeleteConstraintChange(change: DeleteConstraintChange): Array<string>;
+    protected quoteIdentifier(value: string): string;
+    protected serializeLiteral(value: string | number | boolean | null): string;
+}
+export declare class SqliteDatabase<T extends Record<string, SqliteTable>> extends Database<T> {
+    readonly $migration: SqliteMigration;
+    constructor(session: Session, schema: T);
+    select<T extends Table | Record<string, Column>>(value: T): SqliteSelectStatement<T, T extends Table<string, Record<string, Column<unknown>>> ? "single" : "partial", T extends Table<string, Record<string, Column<unknown>>> ? Record<T["$name"], false> : {}>;
+    insert<T extends Table>(table: T): SqliteInsertStatement<T>;
+    update<T extends Table>(table: T): SqliteUpdateStatement<T>;
+    delete<T extends Table>(table: T): SqliteDeleteStatement<T>;
+}
+export declare function blob(name: string): BlobColumn;
+export declare function integer<TMode extends IntegerMode = "number">(name: string, options?: IntegerOptions<TMode>): IntegerColumn<TMode>;
+export declare function numeric(name: string): NumericColumn;
+export declare function real(name: string): RealColumn;
+export declare function text<TMode extends TextMode = "text">(name: string, options?: TextOptions<TMode>): TextColumn<TMode>;
+export declare function unique(...columns: Array<Column>): SqliteUniqueConstraint;
+export declare function check(value: Sql): SqliteCheckConstraint;
+export declare function primaryKey(...columns: Array<Column>): SqlitePrimaryKeyConstraint;
+export declare function foreignKey(columns: Array<Column>, foreignColumns: Array<Column>): SqliteForeignKeyConstraint;
+export declare function index(...columns: Array<Column>): SqliteIndex;
+export declare function uniqueIndex(...columns: Array<Column>): SqliteUniqueIndex;
+export declare function table<TName extends string, TColumns extends Record<string, SqliteColumn>>(name: TName, columns: TColumns, definitions?: (columns: TColumns) => Array<Definition>): SqliteTable<TName, TColumns> & TColumns;