sumak 0.0.4 → 0.0.5

package/dist/index.d.mts

@@ -1,806 +1,49 @@
-import { $ as JoinType, A as MergeNode, B as TableRefNode, C as FunctionCallNode, D as JoinNode, E as IsNullNode, F as ParamNode, G as createDeleteNode, H as UnaryOpNode, I as RawNode, J as createSelectNode, K as createInsertNode, L as SelectNode, M as MergeWhenNotMatched, N as OnConflictNode, O as JsonAccessNode, P as OrderByNode, Q as DialectConfig, R as StarNode, S as FullTextSearchNode, T as InsertNode, U as UpdateNode, V as TemporalClause, W as WindowFunctionNode, X as tableRef, Y as createUpdateNode, Z as CompiledQuery, _ as ExpressionNode, a as PrinterOptions, b as FrameSpec, c as ArrayExprNode, d as CTENode, et as OrderDirection, f as CaseNode, g as ExistsNode, h as DeleteNode, i as Printer, j as MergeWhenMatched, k as LiteralNode, l as BetweenNode, m as ColumnRefNode, n as BasePrinter, nt as SQLDialect, o as ASTNode, p as CastNode, q as createMergeNode, r as PrintMode, rt as SetOperator, s as AliasedExprNode, t as Dialect, tt as Primitive, u as BinaryOpNode, v as FrameBound, w as InNode, x as FullTextSearchMode, y as FrameKind, z as SubqueryNode } from "./_chunks/types.mjs";
-import { n as PgPrinter, t as pgDialect } from "./_chunks/pg.mjs";
-import { n as MssqlPrinter, t as mssqlDialect } from "./_chunks/mssql.mjs";
-import { n as MysqlPrinter, t as mysqlDialect } from "./_chunks/mysql.mjs";
-import { n as SqlitePrinter, t as sqliteDialect } from "./_chunks/sqlite.mjs";
-import { A as InsertType, C as timestamp, D as ColumnType, E as varchar, F as Selectable, I as UpdateType, L as Updateable, M as Nullable, N as SelectRow, O as Generated, P as SelectType, S as time, T as uuid, _ as numeric, a as ColumnDef, b as smallint, c as boolean, d as date, f as doublePrecision, g as jsonb, h as json, i as ColumnBuilder, j as Insertable, k as GeneratedAlways, l as bytea, m as integer, n as TableDefinition, o as bigint, p as enumType, r as defineTable, s as bigserial, t as InferTable, u as char, v as real, w as timestamptz, x as text$1, y as serial } from "./_chunks/index.mjs";
-declare function col(column: string, table?: string): ColumnRefNode;
-declare function colAs(column: string, alias: string, table?: string): ColumnRefNode;
-declare function lit(value: string | number | boolean | null): LiteralNode;
-declare function star(table?: string): StarNode;
-declare function param(index: number, value: unknown): ParamNode;
-declare function raw(sql: string, params?: unknown[]): RawNode;
-declare function subquery(query: SelectNode, alias?: string): SubqueryNode;
-declare function fn(name: string, args: ExpressionNode[], alias?: string): FunctionCallNode;
-declare function binOp(op: string, left: ExpressionNode, right: ExpressionNode): BinaryOpNode;
-declare function unaryOp(op: string, operand: ExpressionNode, position?: "prefix" | "postfix"): UnaryOpNode;
-declare function eq(left: ExpressionNode, right: ExpressionNode): BinaryOpNode;
-declare function neq(left: ExpressionNode, right: ExpressionNode): BinaryOpNode;
-declare function gt(left: ExpressionNode, right: ExpressionNode): BinaryOpNode;
-declare function gte(left: ExpressionNode, right: ExpressionNode): BinaryOpNode;
-declare function lt(left: ExpressionNode, right: ExpressionNode): BinaryOpNode;
-declare function lte(left: ExpressionNode, right: ExpressionNode): BinaryOpNode;
-declare function like(expr: ExpressionNode, pattern: ExpressionNode): BinaryOpNode;
-declare function between(expr: ExpressionNode, low: ExpressionNode, high: ExpressionNode, negated?: boolean): BetweenNode;
-declare function inList(expr: ExpressionNode, values: ExpressionNode[] | SelectNode, negated?: boolean): InNode;
-declare function isNull(expr: ExpressionNode, negated?: boolean): IsNullNode;
-declare class ASTTransformer {
-  transform(node: ASTNode): ASTNode;
-  transformSelect(node: SelectNode): SelectNode;
-  transformInsert(node: InsertNode): InsertNode;
-  transformUpdate(node: UpdateNode): UpdateNode;
-  transformDelete(node: DeleteNode): DeleteNode;
-  transformMerge(node: MergeNode): MergeNode;
-  transformExpression(node: ExpressionNode): ExpressionNode;
-}
-interface ASTVisitor<R = void> {
-  visitSelect(node: SelectNode): R;
-  visitInsert(node: InsertNode): R;
-  visitUpdate(node: UpdateNode): R;
-  visitDelete(node: DeleteNode): R;
-  visitMerge(node: MergeNode): R;
-  visitExpression(node: ExpressionNode): R;
-  visitJoin(node: JoinNode): R;
-  visitOrderBy(node: OrderByNode): R;
-  visitCTE(node: CTENode): R;
-}
-declare function visitNode<R>(node: ASTNode, visitor: ASTVisitor<R>): R;
-/**
- * Type-safe expression wrapper. The T parameter tracks the expression's
- * output type at compile time. At runtime, this is just an ExpressionNode.
- *
- * The `__type` field is a phantom — it never exists at runtime.
- */
-interface Expression<T> {
-  readonly __type: T;
-  readonly node: ExpressionNode;
-}
-declare class MergeBuilder {
-  private node;
-  private paramIndex;
-  constructor(node?: MergeNode, paramIndex?: number);
-  into(table: string | TableRefNode): MergeBuilder;
-  using(source: string | TableRefNode | SubqueryNode, alias: string): MergeBuilder;
-  on(expr: ExpressionNode): MergeBuilder;
-  whenMatched(action: MergeWhenMatched): MergeBuilder;
-  whenNotMatched(action: MergeWhenNotMatched): MergeBuilder;
-  whenMatchedUpdate(set: {
-    column: string;
-    value: ExpressionNode;
-  }[], condition?: ExpressionNode): MergeBuilder;
-  whenMatchedDelete(condition?: ExpressionNode): MergeBuilder;
-  whenNotMatchedInsert(columns: string[], values: ExpressionNode[], condition?: ExpressionNode): MergeBuilder;
-  with(name: string, query: SelectNode, recursive?: boolean): MergeBuilder;
-  build(): MergeNode;
-}
-declare function merge(target: string | TableRefNode): MergeBuilder;
-declare class SelectBuilder {
-  private node;
-  constructor(node?: SelectNode);
-  columns(...cols: (string | ExpressionNode)[]): SelectBuilder;
-  allColumns(): SelectBuilder;
-  distinct(): SelectBuilder;
-  from(table: string | TableRefNode | SubqueryNode, alias?: string): SelectBuilder;
-  where(expr: ExpressionNode): SelectBuilder;
-  join(type: JoinType, table: string | TableRefNode, on?: ExpressionNode, alias?: string): SelectBuilder;
-  innerJoin(table: string | TableRefNode, on: ExpressionNode, alias?: string): SelectBuilder;
-  leftJoin(table: string | TableRefNode, on: ExpressionNode, alias?: string): SelectBuilder;
-  rightJoin(table: string | TableRefNode, on: ExpressionNode, alias?: string): SelectBuilder;
-  groupBy(...exprs: (string | ExpressionNode)[]): SelectBuilder;
-  having(expr: ExpressionNode): SelectBuilder;
-  orderBy(expr: string | ExpressionNode, direction?: OrderDirection, nulls?: "FIRST" | "LAST"): SelectBuilder;
-  limit(expr: ExpressionNode): SelectBuilder;
-  offset(expr: ExpressionNode): SelectBuilder;
-  forSystemTime(clause: TemporalClause): SelectBuilder;
-  forUpdate(): SelectBuilder;
-  with(name: string, query: SelectNode, recursive?: boolean): SelectBuilder;
-  union(query: SelectNode): SelectBuilder;
-  unionAll(query: SelectNode): SelectBuilder;
-  intersect(query: SelectNode): SelectBuilder;
-  except(query: SelectNode): SelectBuilder;
-  private setOp;
-  build(): SelectNode;
-}
-declare function select(...cols: (string | ExpressionNode)[]): SelectBuilder;
-declare class InsertBuilder {
-  private node;
-  private paramIndex;
-  constructor(node?: InsertNode, paramIndex?: number);
-  into(table: string | TableRefNode): InsertBuilder;
-  columns(...cols: string[]): InsertBuilder;
-  values(...vals: unknown[]): InsertBuilder;
-  returning(...exprs: ExpressionNode[]): InsertBuilder;
-  onConflictDoNothing(...columns: string[]): InsertBuilder;
-  onConflictDoUpdate(columns: string[], set: {
-    column: string;
-    value: ExpressionNode;
-  }[], where?: ExpressionNode): InsertBuilder;
-  with(name: string, query: SelectNode, recursive?: boolean): InsertBuilder;
-  build(): InsertNode;
-}
-declare function insert(table: string | TableRefNode): InsertBuilder;
-declare class UpdateBuilder {
-  private node;
-  constructor(node?: UpdateNode);
-  table(table: string | TableRefNode): UpdateBuilder;
-  set(column: string, value: ExpressionNode): UpdateBuilder;
-  where(expr: ExpressionNode): UpdateBuilder;
-  from(table: string | TableRefNode): UpdateBuilder;
-  returning(...exprs: ExpressionNode[]): UpdateBuilder;
-  with(name: string, query: SelectNode, recursive?: boolean): UpdateBuilder;
-  build(): UpdateNode;
-}
-declare function update(table: string | TableRefNode): UpdateBuilder;
-declare class DeleteBuilder {
-  private node;
-  constructor(node?: DeleteNode);
-  from(table: string | TableRefNode): DeleteBuilder;
-  where(expr: ExpressionNode): DeleteBuilder;
-  returning(...exprs: ExpressionNode[]): DeleteBuilder;
-  with(name: string, query: SelectNode, recursive?: boolean): DeleteBuilder;
-  build(): DeleteNode;
-}
-declare function deleteFrom(table: string | TableRefNode): DeleteBuilder;
-interface FormatOptions {
-  indent?: string;
-  uppercase?: boolean;
-}
-declare function formatSQL(sql: string, options?: FormatOptions): string;
-/**
- * Wadler-style pretty printer document algebra.
- *
- * Based on "A prettier printer" (Wadler 1998) and "Strictly Pretty" (Lindig 2000).
- * Used to format SQL output with width-sensitive line breaking.
- */
-type Doc = {
-  tag: "empty";
-} | {
-  tag: "text";
-  text: string;
-} | {
-  tag: "line";
-} | {
-  tag: "nest";
-  indent: number;
-  doc: Doc;
-} | {
-  tag: "group";
-  doc: Doc;
-} | {
-  tag: "concat";
-  docs: Doc[];
-};
-declare function empty(): Doc;
-declare function text(s: string): Doc;
-/** A line break. In flat mode, renders as a single space. */
-declare function line(): Doc;
-/** Increase indentation for the nested document. */
-declare function nest(indent: number, doc: Doc): Doc;
-/** Try to render flat; if too wide, break lines. */
-declare function group(doc: Doc): Doc;
-/** Concatenate documents. */
-declare function concat(...docs: Doc[]): Doc;
-/** Join documents with a separator. */
-declare function join(sep: Doc, docs: Doc[]): Doc;
-/** Convenience: text + line */
-declare function textLine(s: string): Doc;
-/**
- * Render a document to a string.
- *
- * Uses Wadler/Lindig's algorithm: maintain a stack of (indent, mode, doc) triples.
- * mode = "flat" (try single line) or "break" (use line breaks).
- */
-declare function render(doc: Doc, width?: number): string;
-declare function quoteIdentifier(name: string, dialect: SQLDialect): string;
-declare function quoteTableRef(name: string, dialect: SQLDialect, schema?: string): string;
-declare function formatParam(index: number, dialect: SQLDialect): string;
-/**
- * A typed column reference that exposes comparison methods.
- *
- * ```ts
- * // users.id.eq(42) → ("id" = $1) with param [42]
- * // users.name.like("%ali%") → ("name" LIKE '%ali%')
- * ```
- */
-declare class Col<T> {
-  /** @internal */
-  readonly _node: ExpressionNode;
-  readonly _type: T;
-  constructor(column: string, table?: string);
-  /** = */
-  eq(value: T): Expression<boolean>;
-  /** != */
-  neq(value: T): Expression<boolean>;
-  /** > */
-  gt(value: T): Expression<boolean>;
-  /** >= */
-  gte(value: T): Expression<boolean>;
-  /** < */
-  lt(value: T): Expression<boolean>;
-  /** <= */
-  lte(value: T): Expression<boolean>;
-  /** LIKE (string columns only) */
-  like(this: Col<string>, pattern: string): Expression<boolean>;
-  /** IN (value1, value2, ...) */
-  in(values: T[]): Expression<boolean>;
-  /** NOT IN */
-  notIn(values: T[]): Expression<boolean>;
-  /** IS NULL */
-  isNull(): Expression<boolean>;
-  /** IS NOT NULL */
-  isNotNull(): Expression<boolean>;
-  /** BETWEEN low AND high */
-  between(low: T, high: T): Expression<boolean>;
-  /** Compare with another column: col1.eqCol(col2) */
-  eqCol(other: Col<T>): Expression<boolean>;
-  /** As raw Expression<T> for advanced use */
-  toExpr(): Expression<T>;
-}
-declare function resetParams(): void;
-/**
- * Create typed column proxies for a table's columns.
- *
- * Type: { id: Col<number>, name: Col<string>, ... }
- */
-type ColumnProxies<DB, TB extends keyof DB> = { [K in keyof DB[TB] & string]: Col<SelectType<DB[TB][K]>> };
-/**
- * Expression builder callback type.
- *
- * ```ts
- * .where(({ id, name }) => id.eq(42))
- * ```
- */
-type WhereCallback<DB, TB extends keyof DB> = (cols: ColumnProxies<DB, TB>) => Expression<boolean>;
-/** AND two expressions */
-declare function and(left: Expression<boolean>, right: Expression<boolean>): Expression<boolean>;
-/** OR two expressions */
-declare function or(left: Expression<boolean>, right: Expression<boolean>): Expression<boolean>;
-/** Raw literal value as expression */
-declare function val<T extends string | number | boolean | null>(value: T): Expression<T>;
-/** SQL function call */
-declare function sqlFn(name: string, ...args: Expression<any>[]): Expression<any>;
-/** COUNT(*) */
-declare function count(): Expression<number>;
-/** SUM(expr) */
-declare function sum(expr: Expression<number>): Expression<number>;
-/** AVG(expr) */
-declare function avg(expr: Expression<number>): Expression<number>;
-/** MIN(expr) */
-declare function min<T>(expr: Expression<T>): Expression<T>;
-/** MAX(expr) */
-declare function max<T>(expr: Expression<T>): Expression<T>;
-/** COALESCE(expr, fallback) */
-declare function coalesce<T>(expr: Expression<T | null>, fallback: Expression<T>): Expression<T>;
-/** NOT expr */
-declare function not(expr: Expression<boolean>): Expression<boolean>;
-/** EXISTS (subquery) */
-declare function exists(query: SelectNode): Expression<boolean>;
-/** NOT EXISTS (subquery) */
-declare function notExists(query: SelectNode): Expression<boolean>;
-/** CAST(expr AS type) */
-declare function cast<T>(expr: Expression<any>, dataType: string): Expression<T>;
-/**
- * JSON access operator: expr->path, expr->>path, etc.
- *
- * ```ts
- * jsonRef(cols.data, "name", "->>")  // data->>'name'
- * ```
- */
-declare function jsonRef<T = unknown>(expr: Expression<any>, path: string, operator?: "->" | "->>" | "#>" | "#>>"): Expression<T>;
-/**
- * Full-text search expression.
- *
- * Dialect-aware: PG uses tsvector/tsquery, MySQL uses MATCH/AGAINST,
- * SQLite uses FTS5 MATCH, MSSQL uses CONTAINS/FREETEXT.
- *
- * ```ts
- * // PostgreSQL: to_tsvector("name") @@ to_tsquery($1)
- * .where(() => textSearch([cols.name], val("alice")))
- *
- * // MySQL: MATCH(`name`) AGAINST(? IN BOOLEAN MODE)
- * .where(() => textSearch([cols.name], val("alice"), { mode: "boolean" }))
- * ```
- */
-declare function textSearch(columns: Expression<any>[], query: Expression<any>, options?: {
-  mode?: FullTextSearchMode;
-  language?: string;
-}): Expression<boolean>;
-/**
- * CASE expression builder.
- *
- * ```ts
- * case_()
- *   .when(cols.status.eq("active"), val(1))
- *   .when(cols.status.eq("inactive"), val(0))
- *   .else_(val(-1))
- *   .end()
- * ```
- */
-declare function case_(operand?: Expression<any>): CaseBuilder<never>;
-declare class CaseBuilder<T> {
-  /** @internal */
-  private _operand;
-  /** @internal */
-  private _whens;
-  /** @internal */
-  private _else;
-  /** @internal */
-  constructor(operand: ExpressionNode | undefined, whens: {
-    condition: ExpressionNode;
-    result: ExpressionNode;
-  }[], else_?: ExpressionNode);
-  when<R>(condition: Expression<boolean>, result: Expression<R>): CaseBuilder<T | R>;
-  else_<R>(result: Expression<R>): CaseBuilder<T | R>;
-  end(): Expression<T>;
-}
-/**
- * Type-safe DELETE query builder.
- */
-declare class TypedDeleteBuilder<DB, TB extends keyof DB> {
-  /** @internal */
-  readonly _builder: DeleteBuilder;
-  constructor(table: TB & string);
-  /** @internal */
-  private _with;
-  /**
-   * WHERE — callback or raw Expression.
-   */
-  where(exprOrCallback: Expression<boolean> | WhereCallback<DB, TB>): TypedDeleteBuilder<DB, TB>;
-  /**
-   * RETURNING specific columns.
-   */
-  returning<K extends keyof DB[TB] & string>(...cols: K[]): TypedDeleteReturningBuilder<DB, TB, Pick<SelectRow<DB, TB>, K>>;
-  /**
-   * RETURNING all columns.
-   */
-  returningAll(): TypedDeleteReturningBuilder<DB, TB, SelectRow<DB, TB>>;
-  /** WITH (CTE) */
-  with(name: string, query: SelectNode, recursive?: boolean): TypedDeleteBuilder<DB, TB>;
-  build(): DeleteNode;
-  compile(printer: Printer): CompiledQuery;
-}
-declare class TypedDeleteReturningBuilder<DB, _TB extends keyof DB, _R> {
-  /** @internal */
-  readonly _builder: DeleteBuilder;
-  constructor(builder: DeleteBuilder);
-  build(): DeleteNode;
-  compile(printer: Printer): CompiledQuery;
-}
-/**
- * Type-safe INSERT query builder.
- */
-declare class TypedInsertBuilder<DB, TB extends keyof DB> {
-  /** @internal */
-  readonly _builder: InsertBuilder;
-  private _paramIdx;
-  constructor(table: TB & string, paramIdx?: number);
-  /** @internal */
-  private _withBuilder;
-  /**
-   * Insert a single row. Columns/values inferred from Insertable<DB[TB]>.
-   */
-  values(row: Insertable<DB[TB]>): TypedInsertBuilder<DB, TB>;
-  /**
-   * RETURNING specific columns.
-   */
-  returning<K extends keyof DB[TB] & string>(...cols: K[]): TypedInsertReturningBuilder<DB, TB, Pick<SelectRow<DB, TB>, K>>;
-  /**
-   * RETURNING all columns.
-   */
-  returningAll(): TypedInsertReturningBuilder<DB, TB, SelectRow<DB, TB>>;
-  /**
-   * ON CONFLICT DO NOTHING.
-   */
-  onConflictDoNothing(...columns: (keyof DB[TB] & string)[]): TypedInsertBuilder<DB, TB>;
-  /**
-   * ON CONFLICT DO UPDATE.
-   */
-  onConflictDoUpdate(columns: (keyof DB[TB] & string)[], set: {
-    column: keyof DB[TB] & string;
-    value: Expression<any>;
-  }[]): TypedInsertBuilder<DB, TB>;
-  /** WITH (CTE) */
-  with(name: string, query: SelectNode, recursive?: boolean): TypedInsertBuilder<DB, TB>;
-  build(): InsertNode;
-  compile(printer: Printer): CompiledQuery;
-}
-declare class TypedInsertReturningBuilder<DB, _TB extends keyof DB, _R> {
-  /** @internal */
-  readonly _builder: InsertBuilder;
-  constructor(builder: InsertBuilder);
-  build(): InsertNode;
-  compile(printer: Printer): CompiledQuery;
-}
-type MergeProxies<DB, Target extends keyof DB, Source extends keyof DB> = {
-  target: { [K in keyof DB[Target] & string]: Col<any> };
-  source: { [K in keyof DB[Source] & string]: Col<any> };
-};
-declare class TypedMergeBuilder<DB, Target extends keyof DB, Source extends keyof DB> {
-  /** @internal */
-  readonly _builder: MergeBuilder;
-  private _targetTable;
-  private _sourceAlias;
-  private _paramIdx;
-  constructor(targetTable: Target & string, sourceTable: Source & string, sourceAlias: string, on: Expression<boolean>, paramIdx?: number);
-  /** @internal */
-  private _with;
-  whenMatchedThenUpdate(values: Updateable<DB[Target]>, condition?: (proxies: MergeProxies<DB, Target, Source>) => Expression<boolean>): TypedMergeBuilder<DB, Target, Source>;
-  whenMatchedThenDelete(condition?: (proxies: MergeProxies<DB, Target, Source>) => Expression<boolean>): TypedMergeBuilder<DB, Target, Source>;
-  whenNotMatchedThenInsert(row: Insertable<DB[Target]>, condition?: (proxies: MergeProxies<DB, Target, Source>) => Expression<boolean>): TypedMergeBuilder<DB, Target, Source>;
-  with(name: string, query: SelectNode, recursive?: boolean): TypedMergeBuilder<DB, Target, Source>;
-  build(): MergeNode;
-  compile(printer: Printer): CompiledQuery;
-}
-/**
- * Type-safe SELECT query builder.
- *
- * DB = full database schema
- * TB = tables currently in scope (FROM + JOINs)
- * O  = output row type
- */
-declare class TypedSelectBuilder<DB, TB extends keyof DB, O> {
-  /** @internal */
-  readonly _builder: SelectBuilder;
-  private _table;
-  constructor(builder: SelectBuilder, table?: string);
-  /** Select specific columns. Narrows O. */
-  select<K extends keyof O & string>(...cols: K[]): TypedSelectBuilder<DB, TB, Pick<O, K>>;
-  /** Select all columns. */
-  selectAll(): TypedSelectBuilder<DB, TB, O>;
-  /** Select with Expression<T> for computed columns. */
-  selectExpr<Alias extends string, T>(expr: Expression<T>, alias: Alias): TypedSelectBuilder<DB, TB, O & Record<Alias, T>>;
-  /** DISTINCT */
-  distinct(): TypedSelectBuilder<DB, TB, O>;
-  /**
-   * WHERE — accepts callback with typed column proxies OR raw Expression.
-   *
-   * ```ts
-   * // Callback style (recommended)
-   * .where(({ id, name }) => id.eq(42))
-   * .where(({ age }) => age.between(18, 65))
-   *
-   * // Raw Expression style
-   * .where(typedEq(typedCol<number>("id"), typedParam(0, 42)))
-   * ```
-   */
-  where(exprOrCallback: Expression<boolean> | WhereCallback<DB, TB>): TypedSelectBuilder<DB, TB, O>;
-  /**
-   * INNER JOIN.
-   *
-   * ```ts
-   * .innerJoin("posts", ({ users, posts }) => users.id.eqCol(posts.userId))
-   * ```
-   */
-  innerJoin<T extends keyof DB & string>(table: T, onOrCallback: Expression<boolean> | ((cols: JoinProxies<DB, TB, T>) => Expression<boolean>)): TypedSelectBuilder<DB, TB | T, O & SelectRow<DB, T>>;
-  /**
-   * LEFT JOIN — joined columns become nullable.
-   */
-  leftJoin<T extends keyof DB & string>(table: T, onOrCallback: Expression<boolean> | ((cols: JoinProxies<DB, TB, T>) => Expression<boolean>)): TypedSelectBuilder<DB, TB | T, O & Nullable<SelectRow<DB, T>>>;
-  /** RIGHT JOIN */
-  rightJoin<T extends keyof DB & string>(table: T, onOrCallback: Expression<boolean> | ((cols: JoinProxies<DB, TB, T>) => Expression<boolean>)): TypedSelectBuilder<DB, TB | T, Nullable<O> & SelectRow<DB, T>>;
-  /** GROUP BY */
-  groupBy(...cols: (keyof O & string)[]): TypedSelectBuilder<DB, TB, O>;
-  /** HAVING */
-  having(exprOrCallback: Expression<boolean> | WhereCallback<DB, TB>): TypedSelectBuilder<DB, TB, O>;
-  /** ORDER BY */
-  orderBy(col: keyof O & string, direction?: OrderDirection, nulls?: "FIRST" | "LAST"): TypedSelectBuilder<DB, TB, O>;
-  /** LIMIT */
-  limit(n: number): TypedSelectBuilder<DB, TB, O>;
-  /** OFFSET */
-  offset(n: number): TypedSelectBuilder<DB, TB, O>;
-  /** FOR SYSTEM_TIME (SQL:2011 temporal query) */
-  forSystemTime(clause: TemporalClause): TypedSelectBuilder<DB, TB, O>;
-  /** FOR UPDATE */
-  forUpdate(): TypedSelectBuilder<DB, TB, O>;
-  /** WITH (CTE) */
-  with(name: string, query: SelectNode, recursive?: boolean): TypedSelectBuilder<DB, TB, O>;
-  /** UNION */
-  union(query: TypedSelectBuilder<DB, any, O>): TypedSelectBuilder<DB, TB, O>;
-  /** UNION ALL */
-  unionAll(query: TypedSelectBuilder<DB, any, O>): TypedSelectBuilder<DB, TB, O>;
-  /** INTERSECT */
-  intersect(query: TypedSelectBuilder<DB, any, O>): TypedSelectBuilder<DB, TB, O>;
-  /** EXCEPT */
-  except(query: TypedSelectBuilder<DB, any, O>): TypedSelectBuilder<DB, TB, O>;
-  /** FULL JOIN — both sides become nullable. */
-  fullJoin<T extends keyof DB & string>(table: T, onOrCallback: Expression<boolean> | ((cols: JoinProxies<DB, TB, T>) => Expression<boolean>)): TypedSelectBuilder<DB, TB | T, Nullable<O> & Nullable<SelectRow<DB, T>>>;
-  /** CROSS JOIN — cartesian product. */
-  crossJoin<T extends keyof DB & string>(table: T): TypedSelectBuilder<DB, TB | T, O & SelectRow<DB, T>>;
-  /** Build the AST node. */
-  build(): SelectNode;
-  /** Compile to SQL. */
-  compile(printer: Printer): CompiledQuery;
-}
-type JoinProxies<DB, TB extends keyof DB, T extends keyof DB> = { [Table in (TB | T) & string]: ColumnProxies<DB, Table> };
-/**
- * Type-safe UPDATE query builder.
- */
-declare class TypedUpdateBuilder<DB, TB extends keyof DB> {
-  /** @internal */
-  readonly _builder: UpdateBuilder;
-  private _paramIdx;
-  constructor(table: TB & string, paramIdx?: number);
-  /** @internal */
-  private _with;
-  /**
-   * SET columns from an object. All keys optional (Updateable).
-   */
-  set(values: Updateable<DB[TB]>): TypedUpdateBuilder<DB, TB>;
-  /**
-   * SET a single column with an expression.
-   */
-  setExpr(column: keyof DB[TB] & string, value: Expression<any>): TypedUpdateBuilder<DB, TB>;
-  /**
-   * WHERE — callback or raw Expression.
-   */
-  where(exprOrCallback: Expression<boolean> | WhereCallback<DB, TB>): TypedUpdateBuilder<DB, TB>;
-  private get _table();
-  /**
-   * RETURNING specific columns.
-   */
-  returning<K extends keyof DB[TB] & string>(...cols: K[]): TypedUpdateReturningBuilder<DB, TB, Pick<SelectRow<DB, TB>, K>>;
-  /**
-   * RETURNING all columns.
-   */
-  returningAll(): TypedUpdateReturningBuilder<DB, TB, SelectRow<DB, TB>>;
-  /** FROM clause (for UPDATE ... FROM ... WHERE joins). */
-  from<T extends keyof DB & string>(table: T): TypedUpdateBuilder<DB, TB>;
-  /** WITH (CTE) */
-  with(name: string, query: SelectNode, recursive?: boolean): TypedUpdateBuilder<DB, TB>;
-  build(): UpdateNode;
-  compile(printer: Printer): CompiledQuery;
-}
-declare class TypedUpdateReturningBuilder<DB, _TB extends keyof DB, _R> {
-  /** @internal */
-  readonly _builder: UpdateBuilder;
-  constructor(builder: UpdateBuilder);
-  build(): UpdateNode;
-  compile(printer: Printer): CompiledQuery;
-}
-/**
- * Hook context passed to hook handlers.
- */
-interface HookContext<T extends ASTNode = ASTNode> {
-  /** The AST node being processed */
-  node: T;
-  /** Table name (if applicable) */
-  table?: string;
-  /** Compiled query (only in after hooks) */
-  query?: CompiledQuery;
-}
-/**
- * All available hook points in the query lifecycle.
- */
-interface SumakHooks {
-  /** Fires before any query is compiled. Can modify the AST. */
-  "query:before": (ctx: HookContext) => ASTNode | void;
-  /** Fires after a query is compiled to SQL. Can modify the compiled query. */
-  "query:after": (ctx: HookContext & {
-    query: CompiledQuery;
-  }) => CompiledQuery | void;
-  /** Fires before SELECT compilation. Can modify the SelectNode. */
-  "select:before": (ctx: HookContext<SelectNode>) => SelectNode | void;
-  /** Fires before INSERT compilation. Can modify the InsertNode. */
-  "insert:before": (ctx: HookContext<InsertNode>) => InsertNode | void;
-  /** Fires before UPDATE compilation. Can modify the UpdateNode. */
-  "update:before": (ctx: HookContext<UpdateNode>) => UpdateNode | void;
-  /** Fires before DELETE compilation. Can modify the DeleteNode. */
-  "delete:before": (ctx: HookContext<DeleteNode>) => DeleteNode | void;
-  /** Transform result rows. */
-  "result:transform": (rows: Record<string, unknown>[]) => Record<string, unknown>[];
-}
-type HookName = keyof SumakHooks;
-/**
- * Hookable system — register and execute hooks.
- *
- * ```ts
- * const hooks = new Hookable();
- * hooks.hook("select:before", (ctx) => {
- *   // Add soft delete filter
- *   return { ...ctx.node, where: addSoftDelete(ctx.node.where) };
- * });
- * ```
- */
-declare class Hookable {
-  private _hooks;
-  /**
-   * Register a hook handler.
-   * Returns an unregister function.
-   */
-  hook<K extends HookName>(name: K, handler: SumakHooks[K]): () => void;
-  /**
-   * Execute all handlers for a hook.
-   * For AST hooks: each handler can return a modified node, which feeds into the next.
-   * For result hooks: each handler transforms the rows.
-   */
-  callHook<K extends HookName>(name: K, ...args: Parameters<SumakHooks[K]>): ReturnType<SumakHooks[K]> | undefined;
-  /**
-   * Check if any handlers are registered for a hook.
-   */
-  hasHook(name: HookName): boolean;
-  /**
-   * Remove all handlers for a hook.
-   */
-  removeHook(name: HookName): void;
-  /**
-   * Remove all hooks.
-   */
-  removeAllHooks(): void;
-}
-/**
- * Plugin interface for sumak.
- *
- * Plugins can intercept at three points:
- * 1. transformNode — modify the AST before compilation
- * 2. transformQuery — modify the compiled SQL after generation
- * 3. transformResult — modify result rows after execution
- */
-interface SumakPlugin {
-  readonly name: string;
-  /** Transform AST before compilation. Return a new node (never mutate). */
-  transformNode?(node: ASTNode): ASTNode;
-  /** Transform compiled query after SQL generation. */
-  transformQuery?(query: CompiledQuery): CompiledQuery;
-  /** Transform result rows after execution. */
-  transformResult?(rows: Record<string, unknown>[]): Record<string, unknown>[];
-}
-/**
- * Tables config constraint.
- * Each table = Record of ColumnBuilder instances.
- */
-type TablesConfig = Record<string, Record<string, ColumnBuilder<any, any, any>>>;
-interface SumakConfig<T extends TablesConfig> {
-  dialect: Dialect;
-  tables: T;
-  plugins?: SumakPlugin[];
-}
-/**
- * Create a fully typed sumak instance.
- *
- * DB type = typeof tables directly. No `InferDB` mapped type.
- * ColumnBuilder carries __select/__insert/__update phantom fields,
- * so SelectType/InsertType/UpdateType resolve via O(1) indexed access
- * instead of conditional type evaluation.
- *
- * ```ts
- * const db = sumak({
- *   dialect: pgDialect(),
- *   tables: {
- *     users: { id: serial(), name: text().notNull() },
- *   },
- * });
- *
- * db.selectFrom("users").select("id", "name")...
- * ```
- */
-declare function sumak<T extends TablesConfig>(config: SumakConfig<T>): Sumak<T>;
-/**
- * Core sumak instance with hook system.
- */
-declare class Sumak<DB> {
-  private _dialect;
-  private _plugins;
-  private _hooks;
-  constructor(dialect: Dialect, plugins?: SumakPlugin[]);
-  /**
-   * Register a hook handler. Returns an unregister function.
-   *
-   * ```ts
-   * const off = db.hook("query:before", (ctx) => { ... });
-   * off(); // unregister
-   * ```
-   */
-  hook<K extends HookName>(name: K, handler: SumakHooks[K]): () => void;
-  selectFrom<T extends keyof DB & string>(table: T, alias?: string): TypedSelectBuilder<DB, T, SelectRow<DB, T>>;
-  insertInto<T extends keyof DB & string>(table: T): TypedInsertBuilder<DB, T>;
-  update<T extends keyof DB & string>(table: T): TypedUpdateBuilder<DB, T>;
-  deleteFrom<T extends keyof DB & string>(table: T): TypedDeleteBuilder<DB, T>;
-  /**
-   * MERGE INTO target USING source ON condition.
-   *
-   * ```ts
-   * db.mergeInto("users", "staging", "s", ({ target, source }) =>
-   *   target.id.eqCol(source.id),
-   * )
-   * .whenMatchedThenUpdate({ name: "updated" })
-   * .whenNotMatchedThenInsert({ name: "new", email: "e@x.com" })
-   * .compile(db.printer())
-   * ```
-   */
-  mergeInto<T extends keyof DB & string, S extends keyof DB & string>(target: T, source: S, sourceAlias: string, on: (proxies: {
-    target: { [K in keyof DB[T] & string]: Col<any> };
-    source: { [K in keyof DB[S] & string]: Col<any> };
-  }) => Expression<boolean>): TypedMergeBuilder<DB, T, S>;
-  /**
-   * Compile an AST node through the full pipeline:
-   * plugins.transformNode → type-specific hooks → printer → plugins.transformQuery → query hooks
-   */
-  compile(node: ASTNode): CompiledQuery;
-  /**
-   * Transform result rows through plugins and hooks.
-   */
-  transformResult(rows: Record<string, unknown>[]): Record<string, unknown>[];
-  printer(): Printer;
-  private _extractTableName;
-}
-/**
- * Manages plugin execution pipeline.
- * Plugins are applied sequentially in registration order.
- */
-declare class PluginManager {
-  private readonly plugins;
-  constructor(plugins: SumakPlugin[]);
-  /** Apply all transformNode phases in order. */
-  transformNode(node: ASTNode): ASTNode;
-  /** Apply all transformQuery phases in order. */
-  transformQuery(query: CompiledQuery): CompiledQuery;
-  /** Apply all transformResult phases in order. */
-  transformResult(rows: Record<string, unknown>[]): Record<string, unknown>[];
-}
-/**
- * Plugin that prepends a schema name to all table references.
- *
- * ```ts
- * const plugin = new WithSchemaPlugin("public");
- * // SELECT * FROM "users" → SELECT * FROM "public"."users"
- * ```
- */
-declare class WithSchemaPlugin implements SumakPlugin {
-  readonly name = "with-schema";
-  private schema;
-  constructor(schema: string);
-  transformNode(node: ASTNode): ASTNode;
-  private addSchema;
-  private transformSelect;
-  private transformInsert;
-  private transformUpdate;
-  private transformDelete;
-}
-/**
- * Plugin that automatically adds `WHERE deleted_at IS NULL` to
- * SELECT, UPDATE, and DELETE queries for configured tables.
- *
- * ```ts
- * const plugin = new SoftDeletePlugin({ tables: ["users", "posts"] });
- * // SELECT * FROM "users" → SELECT * FROM "users" WHERE "deleted_at" IS NULL
- * ```
- */
-declare class SoftDeletePlugin implements SumakPlugin {
-  readonly name = "soft-delete";
-  private tables;
-  private column;
-  constructor(config: {
-    tables: string[];
-    column?: string;
-  });
-  transformNode(node: ASTNode): ASTNode;
-  private isTargetTable;
-  private softDeleteCondition;
-  private addCondition;
-  private transformSelect;
-  private transformUpdate;
-  private transformDelete;
-}
-/**
- * Plugin that converts snake_case result column names to camelCase.
- *
- * This plugin operates on results only — it does NOT transform the AST.
- * Use it when your database uses snake_case but your TypeScript code uses camelCase.
- */
-declare class CamelCasePlugin implements SumakPlugin {
-  readonly name = "camel-case";
-  transformResult(rows: Record<string, unknown>[]): Record<string, unknown>[];
-}
-declare class SumakError extends Error {
-  constructor(message: string);
-}
-declare class InvalidExpressionError extends SumakError {
-  constructor(message: string);
-}
-declare class UnsupportedDialectFeatureError extends SumakError {
-  constructor(dialect: string, feature: string);
-}
-declare class EmptyQueryError extends SumakError {
-  constructor(queryType: string);
-}
-export { type ASTNode, ASTTransformer, type ASTVisitor, type AliasedExprNode, type ArrayExprNode, BasePrinter, type BetweenNode, type BinaryOpNode, type CTENode, CamelCasePlugin, CaseBuilder, type CaseNode, type CastNode, Col, ColumnBuilder, type ColumnDef, type ColumnProxies, type ColumnRefNode, type ColumnType, type CompiledQuery, DeleteBuilder, type DeleteNode, type Dialect, type DialectConfig, type Doc, EmptyQueryError, type ExistsNode, type Expression, type ExpressionNode, type FormatOptions, type FrameBound, type FrameKind, type FrameSpec, type FullTextSearchMode, type FullTextSearchNode, type FunctionCallNode, type Generated, type GeneratedAlways, type HookContext, type HookName, Hookable, type InNode, type InferTable, InsertBuilder, type InsertNode, type InsertType, type Insertable, InvalidExpressionError, type IsNullNode, type JoinNode, type JoinType, type JsonAccessNode, type LiteralNode, MergeBuilder, type MergeNode, type MergeWhenMatched, type MergeWhenNotMatched, MssqlPrinter, MysqlPrinter, type Nullable, type OnConflictNode, type OrderByNode, type OrderDirection, type ParamNode, PgPrinter, PluginManager, type Primitive, type PrintMode, type Printer, type PrinterOptions, type RawNode, type SQLDialect, SelectBuilder, type SelectNode, type SelectRow, type SelectType, type Selectable, type SetOperator, SoftDeletePlugin, SqlitePrinter, type StarNode, type SubqueryNode, Sumak, type SumakConfig, SumakError, type SumakHooks, type SumakPlugin, type TableDefinition, type TableRefNode, type TemporalClause, TypedDeleteBuilder, TypedDeleteReturningBuilder, TypedInsertBuilder, TypedInsertReturningBuilder, TypedMergeBuilder, TypedSelectBuilder, TypedUpdateBuilder, TypedUpdateReturningBuilder, type UnaryOpNode, UnsupportedDialectFeatureError, UpdateBuilder, type UpdateNode, type UpdateType, type Updateable, type WhereCallback, type WindowFunctionNode, WithSchemaPlugin, and, avg, between, bigint, bigserial, binOp, boolean, bytea, case_, cast, char, coalesce, col, colAs, count, createDeleteNode, createInsertNode, createMergeNode, createSelectNode, createUpdateNode, date, defineTable, deleteFrom, concat as docConcat, empty as docEmpty, group as docGroup, join as docJoin, line as docLine, nest as docNest, render as docRender, text as docText, textLine as docTextLine, doublePrecision, enumType, eq, exists, fn, formatParam, formatSQL, gt, gte, inList, insert, integer, isNull, json, jsonRef, jsonb, like, lit, lt, lte, max, merge, min, mssqlDialect, mysqlDialect, neq, not, notExists, numeric, or, param, pgDialect, quoteIdentifier, quoteTableRef, raw, real, resetParams, select, serial, smallint, sqlFn, sqliteDialect, star, subquery, sum, sumak, tableRef, text$1 as text, textSearch, time, timestamp, timestamptz, unaryOp, update, uuid, val, varchar, visitNode };
+export type { AliasedExprNode, ArrayExprNode, ASTNode, BetweenNode, BinaryOpNode, CaseNode, CastNode, ColumnRefNode, CTENode, DeleteNode, ExistsNode, ExplainNode, ExpressionNode, FrameBound, FrameKind, FrameSpec, FullTextSearchMode, FullTextSearchNode, FunctionCallNode, InNode, InsertMode, InsertNode, IsNullNode, JoinNode, JsonAccessNode, LiteralNode, LockClause, LockMode, MergeNode, MergeWhenMatched, MergeWhenNotMatched, OnConflictNode, OrderByNode, ParamNode, RawNode, SelectNode, StarNode, SubqueryNode, TableRefNode, TemporalClause, UnaryOpNode, UpdateNode, WindowFunctionNode } from "./ast/nodes.mjs";
+export { createDeleteNode, createInsertNode, createMergeNode, createSelectNode, createUpdateNode, tableRef } from "./ast/nodes.mjs";
+export { between, binOp, col, colAs, eq, fn, gt, gte, inList, isNull, like, lit, lt, lte, neq, param, raw, star, subquery, unaryOp } from "./ast/expression.mjs";
+export { ASTTransformer } from "./ast/transformer.mjs";
+export { visitNode } from "./ast/visitor.mjs";
+export type { ASTVisitor } from "./ast/visitor.mjs";
+export type { Expression } from "./ast/typed-expression.mjs";
+export { merge, MergeBuilder } from "./builder/merge.mjs";
+export { select, SelectBuilder } from "./builder/select.mjs";
+export { insert, InsertBuilder } from "./builder/insert.mjs";
+export { update, UpdateBuilder } from "./builder/update.mjs";
+export { deleteFrom, DeleteBuilder } from "./builder/delete.mjs";
+export { BasePrinter } from "./printer/base.mjs";
+export { PgPrinter } from "./printer/pg.mjs";
+export { MssqlPrinter } from "./printer/mssql.mjs";
+export { MysqlPrinter } from "./printer/mysql.mjs";
+export { SqlitePrinter } from "./printer/sqlite.mjs";
+export { formatSQL } from "./printer/formatter.mjs";
+export type { FormatOptions } from "./printer/formatter.mjs";
+export type { Printer, PrinterOptions, PrintMode } from "./printer/types.mjs";
+export { concat as docConcat, empty as docEmpty, group as docGroup, join as docJoin, line as docLine, nest as docNest, render as docRender, text as docText, textLine as docTextLine } from "./printer/document.mjs";
+export type { Doc } from "./printer/document.mjs";
+export { pgDialect } from "./dialect/pg.mjs";
+export { mssqlDialect } from "./dialect/mssql.mjs";
+export { mysqlDialect } from "./dialect/mysql.mjs";
+export { sqliteDialect } from "./dialect/sqlite.mjs";
+export type { Dialect } from "./dialect/types.mjs";
+export { quoteIdentifier, quoteTableRef } from "./utils/identifier.mjs";
+export { formatParam } from "./utils/param.mjs";
+export type { CompiledQuery, DialectConfig, JoinType, OrderDirection, Primitive, SetOperator, SQLDialect } from "./types.mjs";
+export { bigint, bigserial, boolean, bytea, char, ColumnBuilder, date, defineTable, doublePrecision, enumType, integer, json, jsonb, numeric, real, serial, smallint, text, time, timestamp, timestamptz, uuid, varchar } from "./schema/index.mjs";
+export type { ColumnDef, ColumnType, Generated, GeneratedAlways, InferTable, Insertable, InsertType, Nullable, Selectable, SelectRow, SelectType, TableDefinition, Updateable, UpdateType } from "./schema/index.mjs";
+export { abs, and, avg, case_, CaseBuilder, cast, ceil, coalesce, Col, concat, count, countDistinct, currentTimestamp, denseRank, exists, filter, floor, greatest, jsonRef, lag, lead, least, length, lower, max, min, not, notExists, now, ntile, nullif, or, over, rank, resetParams, round, rowNumber, sqlFn, substring, sum, textSearch, trim, upper, val, WindowBuilder } from "./builder/eb.mjs";
+export type { ColumnProxies, WhereCallback } from "./builder/eb.mjs";
+export { sumak, Sumak } from "./sumak.mjs";
+export type { SumakConfig } from "./sumak.mjs";
+export { TypedSelectBuilder } from "./builder/typed-select.mjs";
+export { TypedInsertBuilder, TypedInsertReturningBuilder } from "./builder/typed-insert.mjs";
+export { TypedUpdateBuilder, TypedUpdateReturningBuilder } from "./builder/typed-update.mjs";
+export { TypedDeleteBuilder, TypedDeleteReturningBuilder } from "./builder/typed-delete.mjs";
+export { TypedMergeBuilder } from "./builder/typed-merge.mjs";
+export type { SumakPlugin } from "./plugin/types.mjs";
+export { PluginManager } from "./plugin/plugin-manager.mjs";
+export { WithSchemaPlugin } from "./plugin/with-schema.mjs";
+export { SoftDeletePlugin } from "./plugin/soft-delete.mjs";
+export { CamelCasePlugin } from "./plugin/camel-case.mjs";
+export { Hookable } from "./plugin/hooks.mjs";
+export type { HookContext, HookName, SumakHooks } from "./plugin/hooks.mjs";
+export { EmptyQueryError, InvalidExpressionError, SumakError, UnsupportedDialectFeatureError } from "./errors.mjs";