tempest-db-js 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1084 @@
+/**
+ * tempest-db-js — Phase 2 feasibility spike: the typed query builder.
+ *
+ * The builder is PURE AST + phantom types. It does not touch a database — that is
+ * Phase 4 (`session.execute`). This file proves that:
+ *   - `select(User)` infers the full row type,
+ *   - `select(User, ["id", "name"])` infers a `Pick` projection,
+ *   - `.where(...)` / `.orderBy(...)` reject keys that are not columns,
+ * all at compile time.
+ *
+ * This is a SPIKE, not the final API.
+ */
+
+/** Sort direction for ORDER BY. */
+type SortDirection = "asc" | "desc";
+/** One ORDER BY term. */
+interface OrderTerm {
+    readonly column: string;
+    readonly direction: SortDirection;
+}
+/** Serializable AST for a SELECT. Dialects (Phase 4) compile this to SQL. */
+interface SelectNode {
+    readonly kind: "select";
+    readonly table: string;
+    /** Projected columns, or "*" for the whole row. */
+    readonly columns: readonly string[] | "*";
+    readonly where: CondNode | undefined;
+    readonly orderBy: readonly OrderTerm[];
+    readonly limit: number | undefined;
+    readonly offset: number | undefined;
+}
+/** Operators valid on every column type. */
+interface BaseOperators<T> {
+    /** Equal to. */
+    eq?: T;
+    /** Not equal to. */
+    ne?: T;
+    /** One of the given values (`IN`). */
+    in?: readonly T[];
+    /** None of the given values (`NOT IN`). */
+    notIn?: readonly T[];
+    /** `IS NULL` (true) / `IS NOT NULL` (false). */
+    isNull?: boolean;
+}
+/** Extra operators for ordered types (numbers, bigint, dates). */
+interface OrderedOperators<T> extends BaseOperators<T> {
+    /** Greater than. */
+    gt?: T;
+    /** Greater than or equal. */
+    gte?: T;
+    /** Less than. */
+    lt?: T;
+    /** Less than or equal. */
+    lte?: T;
+    /** Inclusive range `BETWEEN lo AND hi`. */
+    between?: readonly [T, T];
+}
+/** Extra operators for string-like types. */
+interface StringOperators<T> extends BaseOperators<T> {
+    /** `LIKE` pattern (case-sensitive). */
+    like?: string;
+    /** `ILIKE` pattern (case-insensitive). */
+    ilike?: string;
+}
+/**
+ * The operator object allowed for a column of (non-null) type `T`:
+ *   - `string` → equality, `in`, `like`/`ilike`
+ *   - `number` / `bigint` / `Date` → equality, `in`, ordered comparisons, `between`
+ *   - `boolean` → equality, `isNull`
+ *   - anything else (json/blob) → equality and `in` only
+ */
+type OperatorsFor<T> = [T] extends [string] ? StringOperators<T> : [T] extends [number] ? OrderedOperators<T> : [T] extends [bigint] ? OrderedOperators<T> : [T] extends [Date] ? OrderedOperators<T> : [T] extends [boolean] ? BaseOperators<T> : BaseOperators<T>;
+/**
+ * `where` shape: each key must be a real column; each value accepts either a
+ * bare value (shorthand for `eq`) or an operator object restricted to operators
+ * valid for that column's type. A `like` on a `number` column, or `gt` on a
+ * `string`, is a compile error.
+ */
+type WhereInput<Row = Record<string, unknown>> = {
+    [K in keyof Row]?: Row[K] | OperatorsFor<NonNullable<Row[K]>>;
+};
+/** The full set of operator keys, for the dialect compiler to recognize. */
+declare const OPERATORS: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "like", "ilike", "in", "notIn", "between", "isNull"];
+/** One supported operator name. */
+type Operator = (typeof OPERATORS)[number];
+/**
+ * Immutable, chainable SELECT builder.
+ *
+ * @typeParam Full - the complete row type (constrains where/orderBy keys).
+ * @typeParam Proj - the projected result type returned on execution.
+ */
+declare class SelectBuilder<Full, Proj = Full> {
+    readonly node: SelectNode;
+    /** The source model, used to coerce rows on execution. */
+    readonly source: ModelClass;
+    /** Phantom: the result element type, read only by the type system. */
+    readonly __row: Proj;
+    constructor(node: SelectNode, 
+    /** The source model, used to coerce rows on execution. */
+    source: ModelClass);
+    private with;
+    /** Add a WHERE filter: the object form (keys typed) or an `and`/`or`/`not`. */
+    where(input: WhereInput<Full> | Condition): SelectBuilder<Full, Proj>;
+    /** Order by a column of `Full`. */
+    orderBy(column: keyof Full & string, direction?: SortDirection): SelectBuilder<Full, Proj>;
+    /** Limit the number of rows. */
+    limit(n: number): SelectBuilder<Full, Proj>;
+    /** Skip the first `n` rows. */
+    offset(n: number): SelectBuilder<Full, Proj>;
+}
+/** Build a SELECT over every column of the model. */
+declare function select<C extends ModelClass>(model: C): SelectBuilder<InferModel<C>, InferModel<C>>;
+/** Build a SELECT projecting only the given columns. */
+declare function select<C extends ModelClass, K extends keyof InferModel<C> & string>(model: C, columns: readonly K[]): SelectBuilder<InferModel<C>, Pick<InferModel<C>, K>>;
+
+/**
+ * tempest-db-js — logical combinators for `where` (and/or/not).
+ *
+ * A `where` value is either the object form (an implicit AND of its fields) or a
+ * `Condition` built with `and`/`or`/`not`. Both normalize to a `CondNode` tree
+ * that every builder stores and the dialect compiles recursively — so select,
+ * update, delete and join all share one condition language.
+ */
+
+/** Field-map condition (implicit AND of its entries). */
+interface CondFields {
+    readonly kind: "fields";
+    readonly fields: Record<string, unknown>;
+}
+/** Logical condition nodes. */
+type CondNode = CondFields | {
+    readonly kind: "and";
+    readonly parts: readonly CondNode[];
+} | {
+    readonly kind: "or";
+    readonly parts: readonly CondNode[];
+} | {
+    readonly kind: "not";
+    readonly part: CondNode;
+};
+declare const CONDITION: unique symbol;
+/** A composed condition produced by `and`/`or`/`not`. */
+interface Condition {
+    readonly [CONDITION]: true;
+    readonly node: CondNode;
+}
+/** Runtime guard: is this value a composed `Condition`? */
+declare function isCondition(value: unknown): value is Condition;
+/** Normalize a where argument (object form or `Condition`) to a `CondNode`. */
+declare function toCondNode(input: Condition | Record<string, unknown>): CondNode;
+/**
+ * A `where` argument: the object form (keys typed against `Row`) or a `Condition`.
+ *
+ * @typeParam Row - the row type whose columns the field keys are checked against.
+ *   Defaults to a permissive shape; pass it explicitly (e.g. `or<UserRow>(...)`)
+ *   for full key + operator checking inside combinators.
+ */
+type WhereArg<Row = Record<string, unknown>> = WhereInput<Row> | Condition;
+/** Combine conditions with `AND`. */
+declare function and<Row = Record<string, unknown>>(...inputs: WhereArg<NoInfer<Row>>[]): Condition;
+/** Combine conditions with `OR`. */
+declare function or<Row = Record<string, unknown>>(...inputs: WhereArg<NoInfer<Row>>[]): Condition;
+/** Negate a condition with `NOT`. */
+declare function not<Row = Record<string, unknown>>(input: WhereArg<NoInfer<Row>>): Condition;
+
+/**
+ * tempest-db-js — Phase 2: typed INSERT / UPDATE / DELETE builders.
+ *
+ * Like `select`, these are PURE AST + phantom types — no database access. They
+ * are executed in Phase 4 via `session.execute`.
+ *
+ * Safety rule: UPDATE and DELETE start in an *unguarded* type state. A builder
+ * only becomes executable once it has a `.where(...)` clause or an explicit
+ * `.unguarded()` opt-in. Phase 4's `session.execute` will accept only guarded
+ * builders, making an accidental full-table write a compile error.
+ */
+
+/** Columns to return from a mutation, or "*" for the whole row. */
+type Returning = readonly string[] | "*" | null;
+/** Serializable AST for an INSERT. */
+interface InsertNode {
+    readonly kind: "insert";
+    readonly table: string;
+    readonly values: readonly Record<string, unknown>[];
+    readonly returning: Returning;
+}
+/**
+ * INSERT builder.
+ *
+ * @typeParam Full - the complete row type (for `returning`).
+ * @typeParam Ins  - the insert shape (defaults/PK optional).
+ * @typeParam Ret  - execution result: `number` (rows affected) until `returning`.
+ */
+declare class InsertBuilder<Full, Ins, Ret = number> {
+    readonly node: InsertNode;
+    /** The source model, used to coerce returned rows on execution. */
+    readonly source: ModelClass;
+    readonly __row: Ret;
+    constructor(node: InsertNode, 
+    /** The source model, used to coerce returned rows on execution. */
+    source: ModelClass);
+    private with;
+    /** Provide one row or many rows to insert, typed by the insert shape. */
+    values(rows: Ins | readonly Ins[]): InsertBuilder<Full, Ins, Ret>;
+    /** Return the full inserted row(s). */
+    returning(): InsertBuilder<Full, Ins, Full>;
+    /** Return only the given columns of the inserted row(s). */
+    returning<K extends keyof Full & string>(columns: readonly K[]): InsertBuilder<Full, Ins, Pick<Full, K>>;
+}
+/** Build an INSERT into the model's table. */
+declare function insert<C extends ModelClass>(model: C): InsertBuilder<InferModel<C>, InferInsert<C>>;
+/** Serializable AST for an UPDATE. */
+interface UpdateNode {
+    readonly kind: "update";
+    readonly table: string;
+    readonly set: Record<string, unknown>;
+    readonly where: CondNode | undefined;
+    /** True once a where-clause or explicit opt-in makes the write safe. */
+    readonly guarded: boolean;
+    readonly returning: Returning;
+}
+/**
+ * UPDATE builder.
+ *
+ * @typeParam Full     - the complete row type.
+ * @typeParam Guarded  - `true` once safe to execute (has where or opted out).
+ * @typeParam Ret      - execution result type.
+ */
+declare class UpdateBuilder<Full, Guarded extends boolean, Ret = number> {
+    readonly node: UpdateNode;
+    /** The source model, used to coerce returned rows on execution. */
+    readonly source: ModelClass;
+    readonly __row: Ret;
+    readonly __guarded: Guarded;
+    constructor(node: UpdateNode, 
+    /** The source model, used to coerce returned rows on execution. */
+    source: ModelClass);
+    private with;
+    /** The columns to write. Partial — only the given columns change. */
+    set(values: Partial<Full>): UpdateBuilder<Full, Guarded, Ret>;
+    /** Restrict the rows to update. Marks the builder safe to execute. */
+    where(input: WhereInput<Full> | Condition): UpdateBuilder<Full, true, Ret>;
+    /** Explicit opt-in to update EVERY row. Use deliberately. */
+    unguarded(): UpdateBuilder<Full, true, Ret>;
+    /** Return the full updated row(s). */
+    returning(): UpdateBuilder<Full, Guarded, Full>;
+    /** Return only the given columns of the updated row(s). */
+    returning<K extends keyof Full & string>(columns: readonly K[]): UpdateBuilder<Full, Guarded, Pick<Full, K>>;
+}
+/** Build an UPDATE on the model's table. Starts unguarded. */
+declare function update<C extends ModelClass>(model: C): UpdateBuilder<InferModel<C>, false>;
+/** Serializable AST for a DELETE. */
+interface DeleteNode {
+    readonly kind: "delete";
+    readonly table: string;
+    readonly where: CondNode | undefined;
+    readonly guarded: boolean;
+    readonly returning: Returning;
+}
+/**
+ * DELETE builder. Starts unguarded — same safety rule as UPDATE.
+ *
+ * @typeParam Full     - the complete row type.
+ * @typeParam Guarded  - `true` once safe to execute.
+ * @typeParam Ret      - execution result type.
+ */
+declare class DeleteBuilder<Full, Guarded extends boolean, Ret = number> {
+    readonly node: DeleteNode;
+    /** The source model, used to coerce returned rows on execution. */
+    readonly source: ModelClass;
+    readonly __row: Ret;
+    readonly __guarded: Guarded;
+    constructor(node: DeleteNode, 
+    /** The source model, used to coerce returned rows on execution. */
+    source: ModelClass);
+    private with;
+    /** Restrict the rows to delete. Marks the builder safe to execute. */
+    where(input: WhereInput<Full> | Condition): DeleteBuilder<Full, true, Ret>;
+    /** Explicit opt-in to delete EVERY row. Use deliberately. */
+    unguarded(): DeleteBuilder<Full, true, Ret>;
+    /** Return the full deleted row(s). */
+    returning(): DeleteBuilder<Full, Guarded, Full>;
+    /** Return only the given columns of the deleted row(s). */
+    returning<K extends keyof Full & string>(columns: readonly K[]): DeleteBuilder<Full, Guarded, Pick<Full, K>>;
+}
+/** Build a DELETE on the model's table. Starts unguarded. */
+declare function del<C extends ModelClass>(model: C): DeleteBuilder<InferModel<C>, false>;
+
+/**
+ * tempest-db-js — database URL parsing & dialect detection.
+ *
+ * Mirrors SQLAlchemy's `make_url`: a single connection string identifies the
+ * dialect (and optional driver), so switching databases is just swapping the
+ * URL — `sqlite://./app.db` ↔ `postgresql://user:pass@host/db`.
+ *
+ * The driver suffix (`postgresql+pg`, `sqlite+better-sqlite3`, or SQLAlchemy's
+ * async flavors like `postgresql+asyncpg`) is parsed out and ignored for dialect
+ * detection, so URLs copied from a Python service still work here.
+ */
+/** A database dialect tempest-db-js can target. */
+type Dialect = "sqlite" | "postgresql";
+/** A parsed database URL, dialect-neutral. */
+interface ParsedDatabaseUrl {
+    /** The detected dialect. */
+    readonly dialect: Dialect;
+    /** Driver after the `+` in the scheme (e.g. `better-sqlite3`), or `null`. */
+    readonly driver: string | null;
+    /** Host (PostgreSQL), or `null` for SQLite. */
+    readonly host: string | null;
+    /** Port, or `null`. */
+    readonly port: number | null;
+    /** Username, or `null`. */
+    readonly user: string | null;
+    /** Password, or `null`. */
+    readonly password: string | null;
+    /** Database name (PostgreSQL) or file path (SQLite). `:memory:` for in-memory. */
+    readonly database: string | null;
+    /** Extra query-string options (`?sslmode=require`). */
+    readonly options: Readonly<Record<string, string>>;
+    /** The original URL, untouched. */
+    readonly raw: string;
+}
+/** Raised when a URL cannot be parsed or its dialect is unsupported. */
+declare class InvalidDatabaseUrl extends Error {
+    constructor(url: string, reason: string);
+}
+/**
+ * Parse a database URL into its dialect and connection parts.
+ *
+ * @param url A connection string, e.g. `"postgresql://app:app@localhost/app"`
+ *   or `"sqlite:///app.db"`. An async driver suffix (`+asyncpg`, `+aiosqlite`)
+ *   is accepted and ignored for dialect detection.
+ * @returns The parsed, dialect-neutral connection descriptor.
+ * @throws InvalidDatabaseUrl When the URL has no scheme or an unknown dialect.
+ */
+declare function parseDatabaseUrl(url: string): ParsedDatabaseUrl;
+/** Detect just the dialect of a URL, ignoring the rest. */
+declare function detectDialect(url: string): Dialect;
+
+/**
+ * tempest-db-js — row (de)serialization, à la Python's `model_dump` / `model_validate`.
+ *
+ * Rows in tempest-db-js are plain inferred objects. This module converts between three
+ * representations, coercing each field by its column type:
+ *
+ *   - **Row** — native JS values (`Date`, `bigint`, `Uint8Array`, parsed JSON).
+ *   - **Dict** — a plain object of native values, restricted to known columns.
+ *   - **JSON** — a JSON-safe object (`Date` → ISO string, `bigint` → string,
+ *     `Uint8Array` → base64), ready for `JSON.stringify`.
+ *
+ * `fromDict` rebuilds a validated Row from arbitrary input (e.g. an API payload),
+ * coercing strings back to `Date`/`bigint`/`Uint8Array` and validating that
+ * required columns are present.
+ */
+
+/** Raised when `fromDict` input fails validation against the model. */
+declare class ValidationError extends Error {
+    readonly table: string;
+    readonly issues: readonly string[];
+    constructor(table: string, issues: readonly string[]);
+}
+/**
+ * Convert a row to a plain dict of native values, restricted to known columns.
+ * Strips any non-column properties; keeps `Date`/`bigint`/`Uint8Array` as-is.
+ *
+ * @param model The model class.
+ * @param row The row object.
+ * @returns A plain object with one entry per column.
+ */
+declare function toDict<C extends ModelClass>(model: C, row: InferModel<C>): Record<string, unknown>;
+/**
+ * Convert a row to a JSON-safe object: `Date` → ISO string, `bigint` → string,
+ * `Uint8Array` → base64. Ready to hand to `JSON.stringify`.
+ *
+ * @param model The model class.
+ * @param row The row object.
+ * @returns A JSON-safe object with one entry per column.
+ */
+declare function toJSON<C extends ModelClass>(model: C, row: InferModel<C>): Record<string, unknown>;
+/** Convenience: `toJSON` then `JSON.stringify`. */
+declare function stringify<C extends ModelClass>(model: C, row: InferModel<C>): string;
+/**
+ * Build a validated row from an arbitrary dict/JSON object (e.g. an API body).
+ *
+ * Each known column is coerced from the input to its native type (strings back
+ * to `Date`/`bigint`/`Uint8Array`, JSON strings parsed). A column that is
+ * `notNull`, has no default, and is missing/null in the input is a validation
+ * error. Unknown keys in the input are ignored.
+ *
+ * @param model The model class.
+ * @param data The input object (parsed JSON or a plain dict).
+ * @returns A typed row.
+ * @throws ValidationError When a required column is absent.
+ */
+declare function fromDict<C extends ModelClass>(model: C, data: Record<string, unknown>): InferModel<C>;
+/** Parse a JSON string then build a validated row. */
+declare function parse<C extends ModelClass>(model: C, json: string): InferModel<C>;
+
+/**
+ * tempest-db-js — Phase 5: typed joins with composite result types.
+ *
+ * `join(User, "user").innerJoin(Order, "order", { "user.id": "order.userId" })`
+ * yields rows shaped `{ user: UserRow; order: OrderRow }`. A `leftJoin` makes the
+ * joined side nullable (`OrderRow | null`), matching SQL outer-join semantics.
+ *
+ * Columns are aliased in SQL (`"user"."id" AS "user.id"`) so a flat driver row is
+ * split back into one nested object per source, each coerced by its model.
+ */
+
+/** One joined table. */
+interface JoinClause {
+    readonly kind: "inner" | "left";
+    readonly table: string;
+    readonly alias: string;
+    /** Equality pairs of qualified columns: `["user.id", "order.userId"]`. */
+    readonly on: readonly (readonly [string, string])[];
+}
+/** A selected column, qualified by source alias. */
+interface JoinSelection {
+    readonly alias: string;
+    readonly column: string;
+}
+/** `where` filter for a join: keys are `alias.column` refs (object form). */
+type JoinWhereInput = Record<string, unknown>;
+/** Serializable AST for a multi-table SELECT. */
+interface JoinNode {
+    readonly kind: "join_select";
+    readonly base: {
+        readonly table: string;
+        readonly alias: string;
+    };
+    readonly joins: readonly JoinClause[];
+    readonly selections: readonly JoinSelection[];
+    readonly where: CondNode | undefined;
+    readonly orderBy: readonly {
+        readonly ref: string;
+        readonly direction: SortDirection;
+    }[];
+    readonly limit: number | undefined;
+    readonly offset: number | undefined;
+}
+/** A map of source alias → its (possibly nullable) row type. */
+type Sources = Record<string, object | null>;
+/** Every `alias.column` reference across the current sources. */
+type ColRef<S extends Sources> = {
+    [A in keyof S]: `${A & string}.${keyof NonNullable<S[A]> & string}`;
+}[keyof S];
+/** Valid `alias.column` references for a newly joined model. */
+type RightRef<A extends string, C extends ModelClass> = `${A}.${keyof InferModel<C> & string}`;
+/** The `on` condition: map existing-source refs to new-table refs (equality). */
+type JoinOn<S extends Sources, A extends string, C extends ModelClass> = Partial<Record<ColRef<S>, RightRef<A, C>>>;
+/**
+ * Immutable, chainable multi-table SELECT builder.
+ *
+ * @typeParam S - the accumulated sources (alias → row type; nullable for left joins).
+ */
+declare class JoinBuilder<S extends Sources> {
+    readonly node: JoinNode;
+    /** Source models keyed by alias, for SQL expansion and row coercion. */
+    readonly sources: Readonly<Record<string, ModelClass>>;
+    /** Phantom: the composite result row type. */
+    readonly __row: {
+        [A in keyof S]: S[A];
+    };
+    constructor(node: JoinNode, 
+    /** Source models keyed by alias, for SQL expansion and row coercion. */
+    sources: Readonly<Record<string, ModelClass>>);
+    private add;
+    private clause;
+    /** Inner join another model under `alias`. */
+    innerJoin<C extends ModelClass, A extends string>(model: C, alias: A, on: JoinOn<S, A, C>): JoinBuilder<S & {
+        [K in A]: InferModel<C>;
+    }>;
+    /** Left (outer) join another model under `alias` — its side becomes nullable. */
+    leftJoin<C extends ModelClass, A extends string>(model: C, alias: A, on: JoinOn<S, A, C>): JoinBuilder<S & {
+        [K in A]: InferModel<C> | null;
+    }>;
+    /** Filter by `alias.column` references (object form) or an `and`/`or`/`not`. */
+    where(input: Partial<Record<ColRef<S>, unknown>> | Condition): JoinBuilder<S>;
+    /** Order by an `alias.column` reference. */
+    orderBy(ref: ColRef<S>, direction?: SortDirection): JoinBuilder<S>;
+    limit(n: number): JoinBuilder<S>;
+    offset(n: number): JoinBuilder<S>;
+}
+/**
+ * Start a multi-table query from a base model under `alias`.
+ *
+ * @param model The base model.
+ * @param alias The alias to key the base table's rows under in the result.
+ * @returns A `JoinBuilder` with the base source registered.
+ */
+declare function join<C extends ModelClass, A extends string>(model: C, alias: A): JoinBuilder<{
+    [K in A]: InferModel<C>;
+}>;
+
+/**
+ * tempest-db-js — Phase 4a: dialect SQL compilation.
+ *
+ * Turns the dialect-neutral AST (`SelectNode`, `InsertNode`, `UpdateNode`,
+ * `DeleteNode` from Phases 1-2) into `{ sql, params }`. This is the ONLY place
+ * SQL is produced — always parameterized (`?` for SQLite, `$1` for PostgreSQL),
+ * never string interpolation, so it is injection-safe by construction.
+ *
+ * It does NOT touch a database — execution is Phase 4b (`session.execute`).
+ */
+
+/** A compiled, parameterized statement ready to hand to a driver. */
+interface CompiledQuery {
+    readonly sql: string;
+    readonly params: readonly unknown[];
+}
+/** Any compilable AST node. */
+type QueryNode = SelectNode | InsertNode | UpdateNode | DeleteNode | JoinNode;
+/**
+ * Base SQL compiler shared by every dialect. Subclasses customize only what
+ * actually differs between databases (placeholder syntax, `ILIKE` support).
+ */
+declare abstract class BaseDialect {
+    abstract readonly name: "sqlite" | "postgresql";
+    /** Render the n-th (1-based) placeholder. */
+    protected abstract placeholder(index: number): string;
+    /** Render a case-insensitive LIKE for the active dialect. */
+    protected abstract ilike(column: string, param: string): string;
+    /** Quote an identifier (column/table) for the active dialect. */
+    protected quoteId(name: string): string;
+    /** Compile any node to `{ sql, params }`. */
+    compile(node: QueryNode): CompiledQuery;
+    /** Render a qualified `alias.column` ref as `"alias"."column"`. */
+    private qualify;
+    private compileSelect;
+    private compileInsert;
+    private compileUpdate;
+    private compileDelete;
+    private compileJoin;
+    private compileReturning;
+    /**
+     * Compile a condition tree (fields / and / or / not) to SQL. `idFor` renders a
+     * key to a quoted identifier — `quoteId` for single-table, `qualify` for joins —
+     * so select/update/delete/join all share this one compiler.
+     */
+    private compileCondition;
+    private compileOperator;
+    private compileIn;
+}
+/** SQLite dialect: `?` placeholders; `ILIKE` falls back to `LIKE` (ASCII-insensitive). */
+declare class SqliteDialect extends BaseDialect {
+    readonly name: "sqlite";
+    protected placeholder(): string;
+    protected ilike(column: string, param: string): string;
+}
+/** PostgreSQL dialect: `$1` placeholders; native `ILIKE`. */
+declare class PostgresDialect extends BaseDialect {
+    readonly name: "postgresql";
+    protected placeholder(index: number): string;
+    protected ilike(column: string, param: string): string;
+}
+/** Get a dialect instance by name. */
+declare function getDialect(name: "sqlite" | "postgresql"): BaseDialect;
+
+/** The outcome of running one statement. */
+interface DriverResult {
+    /** Returned rows (SELECT or `RETURNING`); empty otherwise. */
+    readonly rows: Record<string, unknown>[];
+    /** Rows affected by an INSERT/UPDATE/DELETE. */
+    readonly changes: number;
+}
+/** A synchronous driver (SQLite). */
+interface SyncDriver {
+    execute(sql: string, params: readonly unknown[]): DriverResult;
+    /** Lazily iterate rows (for `.stream()`), if the driver supports it. */
+    iterate?(sql: string, params: readonly unknown[]): IterableIterator<Record<string, unknown>>;
+    close(): void;
+}
+/** An asynchronous driver (PostgreSQL, or an async-wrapped SQLite). */
+interface AsyncDriver {
+    execute(sql: string, params: readonly unknown[]): Promise<DriverResult>;
+    /** Lazily iterate rows (for `.stream()`), if the driver supports it. */
+    iterate?(sql: string, params: readonly unknown[]): AsyncIterableIterator<Record<string, unknown>>;
+    close(): Promise<void>;
+}
+/** SQLite driver backed by Node's built-in `node:sqlite` (zero install). */
+declare class NodeSqliteDriver implements SyncDriver {
+    private readonly db;
+    constructor(database: any);
+    /** Open a `node:sqlite` database at the given path (or `:memory:`). */
+    static open(path: string): NodeSqliteDriver;
+    execute(sql: string, params: readonly unknown[]): DriverResult;
+    iterate(sql: string, params: readonly unknown[]): IterableIterator<Record<string, unknown>>;
+    close(): void;
+}
+type AnySelect = SelectBuilder<any, any>;
+type AnyInsert = InsertBuilder<any, any, any>;
+type GuardedUpdate = UpdateBuilder<any, true, any>;
+type GuardedDelete = DeleteBuilder<any, true, any>;
+type AnyJoin = JoinBuilder<any>;
+/**
+ * A builder that is safe to execute. UPDATE/DELETE are accepted only once
+ * guarded (after `.where()` or `.unguarded()`) — an unguarded full-table write
+ * is a compile error at the execution boundary.
+ */
+type Executable = AnySelect | AnyInsert | GuardedUpdate | GuardedDelete | AnyJoin;
+/** The element type a builder yields on execution. */
+type RowOf<B> = B extends {
+    readonly __row: infer R;
+} ? R : never;
+/** Raised by `.one()` when the row count is not exactly one. */
+declare class NoResultError extends Error {
+    constructor(message: string);
+}
+/** Synchronous result view over already-fetched rows. */
+declare class SyncResult<Row> {
+    private readonly rows;
+    private readonly changes;
+    constructor(rows: Row[], changes: number);
+    all(): Row[];
+    first(): Row | null;
+    one(): Row;
+    oneOrNull(): Row | null;
+    scalar(): unknown;
+    scalars(): unknown[];
+    rowsAffected(): number;
+}
+/** Asynchronous result view (terminals return Promises). */
+declare class AsyncResult<Row> {
+    private readonly inner;
+    constructor(inner: Promise<SyncResult<Row>>);
+    all(): Promise<Row[]>;
+    first(): Promise<Row | null>;
+    one(): Promise<Row>;
+    oneOrNull(): Promise<Row | null>;
+    scalar(): Promise<unknown>;
+    scalars(): Promise<unknown[]>;
+    rowsAffected(): Promise<number>;
+}
+/** A synchronous unit of work (SQLite). */
+declare class SyncSession {
+    private readonly driver;
+    private readonly dialect;
+    constructor(driver: SyncDriver, dialect: BaseDialect);
+    /** Compile, run, and coerce a builder into a result. */
+    execute<B extends Executable>(builder: B): SyncResult<RowOf<B>>;
+    /** Run `fn` inside a transaction: commit on success, rollback on throw. */
+    transaction<T>(fn: (tx: SyncSession) => T): T;
+    /** Run `fn` inside a SAVEPOINT (nested transaction). */
+    beginNested<T>(fn: (sp: SyncSession) => T): T;
+    /**
+     * Lazily iterate result rows without materializing them all. Falls back to a
+     * buffered fetch when the driver has no native iteration.
+     */
+    stream<B extends Executable>(builder: B): IterableIterator<RowOf<B>>;
+    close(): void;
+}
+/** An asynchronous unit of work. */
+declare class AsyncSession {
+    private readonly driver;
+    private readonly dialect;
+    constructor(driver: AsyncDriver, dialect: BaseDialect);
+    execute<B extends Executable>(builder: B): AsyncResult<RowOf<B>>;
+    /** Lazily iterate result rows. Uses driver streaming when available. */
+    stream<B extends Executable>(builder: B): AsyncIterableIterator<RowOf<B>>;
+    transaction<T>(fn: (tx: AsyncSession) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+/** Connection-pool tuning (PostgreSQL; ignored by SQLite). */
+interface PoolOptions {
+    /** Max connections in the pool. */
+    readonly size?: number;
+    /** Close a connection after it sits idle this long (ms). */
+    readonly idleTimeoutMs?: number;
+    /** Give up acquiring a connection after this long (ms). */
+    readonly connectTimeoutMs?: number;
+}
+/** Options shared by both engine flavors. */
+interface EngineOptions {
+    /** Override the driver detected from the URL (e.g. `"better-sqlite3"`). */
+    readonly driver?: string;
+    /** Connection-pool tuning (PostgreSQL only). */
+    readonly pool?: PoolOptions;
+}
+/** A synchronous engine (SQLite only). */
+declare class SyncEngine {
+    private readonly driver;
+    readonly dialect: Dialect;
+    constructor(driver: SyncDriver);
+    session(): SyncSession;
+    transaction<T>(fn: (tx: SyncSession) => T): T;
+    close(): void;
+}
+/** An asynchronous engine. */
+declare class AsyncEngine {
+    private readonly driver;
+    readonly dialect: Dialect;
+    constructor(driver: AsyncDriver, dialect: Dialect);
+    session(): AsyncSession;
+    transaction<T>(fn: (tx: AsyncSession) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+/**
+ * Create a **synchronous** engine from a database URL. SQLite only — PostgreSQL
+ * has no sane synchronous driver in Node, so a Postgres URL throws, pointing at
+ * the async `createEngine`.
+ *
+ * @param url A SQLite URL, e.g. `"sqlite:///app.db"` or `"sqlite://:memory:"`.
+ * @param options Engine options.
+ * @returns A `SyncEngine`.
+ */
+declare function createSyncEngine(url: string, options?: EngineOptions): SyncEngine;
+/**
+ * Create an **asynchronous** engine from a database URL (the default). Works for
+ * both SQLite (sync driver wrapped as async) and PostgreSQL (postgres.js,
+ * lazy-loaded).
+ *
+ * @param url A database URL, e.g. `"postgresql://app@localhost/app"` or
+ *   `"sqlite:///app.db"`.
+ * @param options Engine options.
+ * @returns An `AsyncEngine`.
+ */
+declare function createEngine(url: string, options?: EngineOptions): AsyncEngine;
+
+/**
+ * tempest-db-js — Phase 7: typed repository + pagination.
+ *
+ * `BaseRepository<Model>` mirrors the `tempest-fastapi-sdk` repository: a thin,
+ * fully-typed CRUD + pagination layer over a model and an async session. The
+ * 404-convention is honored — `getById` throws when absent, collection methods
+ * return `[]` (never a "not found" error for an empty list).
+ */
+
+/** Pagination request — 1-indexed page. */
+interface PaginationFilter<Row> {
+    readonly page?: number;
+    readonly pageSize?: number;
+    readonly orderBy?: keyof Row & string;
+    readonly ascending?: boolean;
+    readonly filters?: WhereInput<Row>;
+}
+/** A page of results plus metadata (mirrors `BasePaginationSchema`). */
+interface PaginationResult<Row> {
+    readonly items: Row[];
+    readonly total: number;
+    readonly page: number;
+    readonly pageSize: number;
+    readonly pages: number;
+}
+/** Raised by single-record lookups (`getById`) when nothing matches (404). */
+declare class RecordNotFound extends Error {
+    constructor(table: string, id: unknown);
+}
+/**
+ * A fully-typed CRUD + pagination repository over a model and an async session.
+ *
+ * @typeParam C - the model class.
+ */
+declare class BaseRepository<C extends ModelClass> {
+    protected readonly model: C;
+    protected readonly session: AsyncSession;
+    private readonly pk;
+    constructor(model: C, session: AsyncSession);
+    /** All rows matching `filters` (or everything). Empty list when none match. */
+    list(filters?: WhereInput<InferModel<C>>): Promise<InferModel<C>[]>;
+    /** The first row matching `filters`, or `null`. */
+    first(filters?: WhereInput<InferModel<C>>): Promise<InferModel<C> | null>;
+    /** A single row by primary key, or `null`. */
+    getByIdOrNull(id: unknown): Promise<InferModel<C> | null>;
+    /** A single row by primary key; throws `RecordNotFound` when absent. */
+    getById(id: unknown): Promise<InferModel<C>>;
+    /** Whether any row matches `filters`. */
+    exists(filters: WhereInput<InferModel<C>>): Promise<boolean>;
+    /** How many rows match `filters` (or the whole table). */
+    count(filters?: WhereInput<InferModel<C>>): Promise<number>;
+    /** Insert one row, returning the created row. */
+    create(data: InferInsert<C>): Promise<InferModel<C>>;
+    /** Insert many rows, returning the created rows. */
+    createMany(data: readonly InferInsert<C>[]): Promise<InferModel<C>[]>;
+    /** Update rows matching `filters`; returns the number of rows affected. */
+    update(filters: WhereInput<InferModel<C>>, set: Partial<InferModel<C>>): Promise<number>;
+    /** Delete rows matching `filters`; returns the number of rows affected. */
+    delete(filters: WhereInput<InferModel<C>>): Promise<number>;
+    /**
+     * A page of rows plus metadata. `total` counts all matching rows.
+     *
+     * @param filter Page, size, ordering and filters.
+     * @returns The page and pagination metadata.
+     */
+    paginate(filter?: PaginationFilter<InferModel<C>>): Promise<PaginationResult<InferModel<C>>>;
+}
+
+/**
+ * tempest-db-js — typed relations (hasMany / belongsTo) with eager loading.
+ *
+ * Relations are plain descriptors that reference another model plus the local /
+ * foreign key. `loadRelations` fetches the related rows in **one query per
+ * relation** (no N+1), groups them, and attaches them to the base rows — with
+ * the result type widened so each relation key is typed (`Row[]` for hasMany,
+ * `Row | null` for belongsTo).
+ */
+
+/** A one-to-many relation: each base row owns many target rows. */
+interface HasMany<C extends ModelClass> {
+    readonly kind: "hasMany";
+    readonly target: () => C;
+    /** Column on the base row (usually its primary key). */
+    readonly localKey: string;
+    /** Column on the target row pointing back to the base row. */
+    readonly foreignKey: string;
+}
+/** A many-to-one relation: each base row points to one target row. */
+interface BelongsTo<C extends ModelClass> {
+    readonly kind: "belongsTo";
+    readonly target: () => C;
+    /** Column on the base row holding the foreign key. */
+    readonly localKey: string;
+    /** Column on the target row (usually its primary key). */
+    readonly foreignKey: string;
+}
+type Relation = HasMany<any> | BelongsTo<any>;
+/** Declare a one-to-many relation. */
+declare function hasMany<C extends ModelClass>(target: () => C, keys: {
+    localKey: string;
+    foreignKey: string;
+}): HasMany<C>;
+/** Declare a many-to-one relation. */
+declare function belongsTo<C extends ModelClass>(target: () => C, keys: {
+    localKey: string;
+    foreignKey: string;
+}): BelongsTo<C>;
+/** The value a relation contributes to a loaded row. */
+type RelationValue<R> = R extends HasMany<infer C> ? InferModel<C>[] : R extends BelongsTo<infer C> ? InferModel<C> | null : never;
+/** A base row augmented with its loaded relations. */
+type WithRelations<Row, Spec extends Record<string, Relation>> = Row & {
+    [K in keyof Spec]: RelationValue<Spec[K]>;
+};
+/**
+ * Eager-load relations onto a set of base rows. One query per relation.
+ *
+ * @param session The async session to query through.
+ * @param rows The already-loaded base rows.
+ * @param spec A map of relation name → relation descriptor.
+ * @returns The base rows, each augmented with its relation values.
+ */
+declare function loadRelations<Row extends Record<string, unknown>, Spec extends Record<string, Relation>>(session: AsyncSession, rows: Row[], spec: Spec): Promise<WithRelations<Row, Spec>[]>;
+
+/**
+ * tempest-db-js — feasibility spike for Phase 1.
+ *
+ * Proves the central design claim: a class-based, SQLAlchemy-style model whose
+ * fields are runtime column-builders can drive full static row-type inference in
+ * TypeScript, despite TS erasing types at runtime.
+ *
+ * This is a SPIKE, not the final API. It validates the type machinery only.
+ */
+/** Phantom marker carrying the static TS type a column maps to. */
+declare const TYPE: unique symbol;
+/** Column flags that influence the inferred row/insert shape. */
+interface ColumnFlags {
+    readonly primaryKey: boolean;
+    readonly notNull: boolean;
+    readonly hasDefault: boolean;
+}
+/**
+ * The canonical, dialect-neutral kind of a column type. Mirrors SQLAlchemy's
+ * generic types (e.g. `String` → varchar, `Text` → text). Dialect renderers
+ * (Phase 4/6) map each kind + meta to concrete SQL per database.
+ */
+type ColumnTypeKind = "smallint" | "integer" | "bigint" | "numeric" | "real" | "double" | "varchar" | "text" | "char" | "boolean" | "date" | "time" | "datetime" | "timestamp" | "blob" | "json" | "uuid" | "enum";
+/** Parameters that refine a column type and feed the migration IR / DDL. */
+interface ColumnTypeMeta {
+    /** Max length for `varchar`/`char`. */
+    readonly length?: number | undefined;
+    /** Total digits for `numeric`. */
+    readonly precision?: number | undefined;
+    /** Digits after the decimal point for `numeric`. */
+    readonly scale?: number | undefined;
+    /** `WITH TIME ZONE` for `timestamp`/`time`. */
+    readonly withTimezone?: boolean | undefined;
+    /** Allowed values for `enum`. */
+    readonly values?: readonly string[] | undefined;
+    /** Render as `JSONB` (PostgreSQL) instead of `JSON`. */
+    readonly jsonb?: boolean | undefined;
+}
+/** A structured, dialect-neutral column type descriptor. */
+interface ColumnType {
+    readonly kind: ColumnTypeKind;
+    readonly meta: ColumnTypeMeta;
+}
+/**
+ * A portable default expression. The token is dialect-neutral; the renderer
+ * (Phase 4/6) maps it to the right SQL per database — e.g. `"now"` becomes
+ * `CURRENT_TIMESTAMP` on SQLite and `now()` on PostgreSQL. Use `{ raw }` as an
+ * escape hatch for a verbatim SQL fragment.
+ */
+type PortableExpression = "now" | "current_date" | "current_time" | "uuidv4" | {
+    readonly raw: string;
+};
+/**
+ * A column default. Either a constant literal value or a server-side expression
+ * evaluated by the database (mirrors SQLAlchemy's `default` vs `server_default`).
+ * Feeds the migration IR (`DefaultIR`).
+ */
+type DefaultValue = {
+    readonly kind: "literal";
+    readonly value: unknown;
+} | {
+    readonly kind: "expression";
+    readonly expression: PortableExpression;
+};
+/** Portable server-side default expressions, à la SQLAlchemy's `func`. */
+declare const sql: {
+    /** Current timestamp at insert (`CURRENT_TIMESTAMP` / `now()`). */
+    readonly now: () => DefaultValue;
+    /** Current date. */
+    readonly currentDate: () => DefaultValue;
+    /** Current time. */
+    readonly currentTime: () => DefaultValue;
+    /** A freshly generated UUID v4 (`gen_random_uuid()` / portable fallback). */
+    readonly uuidv4: () => DefaultValue;
+    /** Escape hatch: a verbatim SQL expression rendered as-is. */
+    readonly raw: (expression: string) => DefaultValue;
+};
+/**
+ * A typed column builder. Holds runtime metadata (structured `type`, `flags`,
+ * `default`, `onUpdate`) and a phantom static type `T` used purely for inference.
+ */
+declare class Column<T, F extends ColumnFlags = ColumnFlags> {
+    readonly type: ColumnType;
+    readonly flags: F;
+    /** The default applied on insert, or `null` for none. */
+    readonly defaultValue: DefaultValue | null;
+    /** The value re-applied on update (e.g. `updated_at`), or `null`. */
+    readonly onUpdateValue: DefaultValue | null;
+    /** Phantom: never read at runtime, only inspected by the type system. */
+    readonly [TYPE]: T;
+    constructor(type: ColumnType, flags: F, 
+    /** The default applied on insert, or `null` for none. */
+    defaultValue?: DefaultValue | null, 
+    /** The value re-applied on update (e.g. `updated_at`), or `null`. */
+    onUpdateValue?: DefaultValue | null);
+    primaryKey(): Column<T, F & {
+        primaryKey: true;
+        hasDefault: true;
+    }>;
+    notNull(): Column<T, F & {
+        notNull: true;
+    }>;
+    /**
+     * Set the insert-time default: a constant value of type `T`, or a portable
+     * server-side expression from {@link sql} (e.g. `sql.now()`, `sql.uuidv4()`).
+     */
+    default(value: T | DefaultValue): Column<T, F & {
+        hasDefault: true;
+    }>;
+    /**
+     * Re-apply a value whenever the row is updated (e.g. an `updated_at` column
+     * with `sql.now()`). Mirrors SQLAlchemy's `onupdate`.
+     */
+    onUpdate(value: T | DefaultValue): Column<T, F>;
+}
+/**
+ * Column factory mirroring SQLAlchemy's typed column constructors. Each entry
+ * pairs a distinct SQL type with the TypeScript type it maps to.
+ *
+ * Notable mappings:
+ *   - `varchar(n)` (`VARCHAR(n)`) is distinct from `text` (`TEXT`).
+ *   - `bigInteger` maps to `bigint` (not `number`) to keep 64-bit precision.
+ *   - `numeric`/`decimal` map to `string` — JavaScript has no exact decimal, and
+ *     stringifying preserves precision instead of losing it to a float.
+ *   - `json<T>()` carries the parsed value type; `jsonb` is the PostgreSQL variant.
+ *   - `enum(...)` infers a string-literal union from its values.
+ */
+declare const column: {
+    /** `SMALLINT` → `number`. */
+    readonly smallInteger: () => Column<number, ColumnFlags>;
+    /** `INTEGER` → `number`. */
+    readonly integer: () => Column<number, ColumnFlags>;
+    /** `BIGINT` → `bigint` (64-bit precision preserved). */
+    readonly bigInteger: () => Column<bigint, ColumnFlags>;
+    /** `NUMERIC(precision, scale)` → `string` (exact decimal, no float loss). */
+    readonly numeric: (precision?: number, scale?: number) => Column<string, ColumnFlags>;
+    /** Alias of {@link column.numeric}. */
+    readonly decimal: (precision?: number, scale?: number) => Column<string, ColumnFlags>;
+    /** `REAL` → `number`. */
+    readonly real: () => Column<number, ColumnFlags>;
+    /** `DOUBLE PRECISION` → `number`. */
+    readonly double: () => Column<number, ColumnFlags>;
+    /** `VARCHAR(length)` → `string`. Distinct from {@link column.text}. */
+    readonly varchar: (length: number) => Column<string, ColumnFlags>;
+    /** Alias of {@link column.varchar} (SQLAlchemy's `String`). */
+    readonly string: (length: number) => Column<string, ColumnFlags>;
+    /** `CHAR(length)` → `string` (fixed-width). */
+    readonly char: (length: number) => Column<string, ColumnFlags>;
+    /** `TEXT` → `string` (unbounded). Distinct from {@link column.varchar}. */
+    readonly text: () => Column<string, ColumnFlags>;
+    /** `BOOLEAN` → `boolean`. */
+    readonly boolean: () => Column<boolean, ColumnFlags>;
+    /** `DATE` → `Date`. */
+    readonly date: () => Column<Date, ColumnFlags>;
+    /** `TIME` → `string`. Pass `{ timezone: true }` for `WITH TIME ZONE`. */
+    readonly time: (options?: {
+        timezone?: boolean;
+    }) => Column<string, ColumnFlags>;
+    /**
+     * `DATETIME`/`TIMESTAMP` → `Date` (SQLAlchemy's generic `DateTime`). Pass
+     * `{ timezone: true }` for `WITH TIME ZONE`. Pair with `.default(sql.now())`
+     * and `.onUpdate(sql.now())` for managed `created_at`/`updated_at` columns.
+     */
+    readonly datetime: (options?: {
+        timezone?: boolean;
+    }) => Column<Date, ColumnFlags>;
+    /** `TIMESTAMP` → `Date` (SQL-specific). Pass `{ timezone: true }`. */
+    readonly timestamp: (options?: {
+        timezone?: boolean;
+    }) => Column<Date, ColumnFlags>;
+    /** `BLOB`/`BYTEA` → `Uint8Array`. */
+    readonly blob: () => Column<Uint8Array, ColumnFlags>;
+    /** `JSON` → the given parsed value type `T` (defaults to `unknown`). */
+    readonly json: <T = unknown>() => Column<T, ColumnFlags>;
+    /** `JSONB` (PostgreSQL) → the given parsed value type `T`. */
+    readonly jsonb: <T = unknown>() => Column<T, ColumnFlags>;
+    /** `UUID` → `string`. */
+    readonly uuid: () => Column<string, ColumnFlags>;
+    /** `ENUM(...values)` → a string-literal union of the given values. */
+    readonly enum: <const E extends string>(...values: E[]) => Column<E, ColumnFlags>;
+};
+/** Base class every model extends, SQLAlchemy-declarative style. */
+declare abstract class Model {
+    static tablename: string;
+}
+/**
+ * Reflect a model class into its column map at runtime, keyed by column name.
+ *
+ * Instantiates the class once and collects every field that is a `Column`. Used
+ * by the serialization layer and (Phase 6) the migration schema reflector.
+ *
+ * @param model The model class (subclass of `Model`).
+ * @returns A record of column name → `Column` instance.
+ */
+declare function columnsOf(model: ModelClass): Record<string, Column<unknown>>;
+/** Pull the static type out of a Column. */
+type ColType<C> = C extends Column<infer T, infer _F> ? T : never;
+/** Keys of the model instance whose values are Columns. */
+type ColumnKeys<M> = {
+    [K in keyof M]: M[K] extends Column<unknown, ColumnFlags> ? K : never;
+}[keyof M];
+/** Constructor type for a Model subclass. */
+type ModelClass = (new () => Model) & {
+    tablename: string;
+};
+/** Flatten an intersection into a single object literal for clean inference. */
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/** The nullability-aware value a column contributes to a row. */
+type ColValue<Col> = Col extends Column<infer T, infer F> ? F extends {
+    notNull: true;
+} | {
+    primaryKey: true;
+} ? T : T | null : never;
+/** True when a column has a default (or is a PK) — i.e. optional on insert. */
+type HasDefault<Col> = Col extends Column<unknown, infer F> ? F extends {
+    hasDefault: true;
+} ? true : false : false;
+/** Keys of the model whose columns are optional on insert. */
+type OptionalInsertKeys<I> = {
+    [K in ColumnKeys<I>]: HasDefault<I[K]> extends true ? K : never;
+}[ColumnKeys<I>];
+/**
+ * Infer the SELECT row shape from a model class: every column field becomes its
+ * mapped static type. Columns marked notNull/primaryKey are non-nullable; others
+ * are `T | null` (SQL semantics — an unconstrained column can be NULL).
+ */
+type InferModel<C extends ModelClass> = {
+    [K in ColumnKeys<InstanceType<C>>]: ColValue<InstanceType<C>[K]>;
+};
+/**
+ * Infer the INSERT shape: columns with a default (or PK) are optional; the rest
+ * are required. Nullability is preserved on both sides.
+ */
+type InferInsert<C extends ModelClass> = Simplify<{
+    [K in OptionalInsertKeys<InstanceType<C>>]?: ColValue<InstanceType<C>[K]>;
+} & {
+    [K in Exclude<ColumnKeys<InstanceType<C>>, OptionalInsertKeys<InstanceType<C>>>]: ColValue<InstanceType<C>[K]>;
+}>;
+
+export { type AsyncDriver, AsyncEngine, AsyncResult, AsyncSession, BaseDialect, BaseRepository, type BelongsTo, type ColRef, type ColType, Column, type ColumnFlags, type ColumnType, type ColumnTypeKind, type ColumnTypeMeta, type CompiledQuery, type CondNode, type Condition, type DefaultValue, DeleteBuilder, type DeleteNode, type Dialect, type DriverResult, type EngineOptions, type Executable, type HasMany, type InferInsert, type InferModel, InsertBuilder, type InsertNode, InvalidDatabaseUrl, JoinBuilder, type JoinClause, type JoinNode, type JoinOn, type JoinSelection, type JoinWhereInput, Model, type ModelClass, NoResultError, NodeSqliteDriver, OPERATORS, type Operator, type OperatorsFor, type OrderTerm, type PaginationFilter, type PaginationResult, type ParsedDatabaseUrl, type PoolOptions, type PortableExpression, PostgresDialect, type QueryNode, RecordNotFound, type Relation, type RelationValue, type Returning, type RowOf, SelectBuilder, type SelectNode, type SortDirection, type Sources, SqliteDialect, type SyncDriver, SyncEngine, SyncResult, SyncSession, UpdateBuilder, type UpdateNode, ValidationError, type WhereArg, type WhereInput, type WithRelations, and, belongsTo, column, columnsOf, createEngine, createSyncEngine, del, detectDialect, fromDict, getDialect, hasMany, insert, isCondition, join, loadRelations, not, or, parse, parseDatabaseUrl, select, sql, stringify, toCondNode, toDict, toJSON, update };