sumak 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,659 @@
+import { A as RawNode, B as createSelectNode, C as IsNullNode, D as OnConflictNode, E as LiteralNode, F as UnaryOpNode, G as JoinType, H as tableRef, I as UpdateNode, J as SQLDialect, K as OrderDirection, L as WindowFunctionNode, M as StarNode, N as SubqueryNode, O as OrderByNode, P as TableRefNode, R as createDeleteNode, S as InsertNode, T as JsonAccessNode, U as CompiledQuery, V as createUpdateNode, W as DialectConfig, Y as SetOperator, _ as FrameBound, a as PrinterOptions, b as FunctionCallNode, c as BetweenNode, d as CaseNode, f as CastNode, g as ExpressionNode, h as ExistsNode, i as Printer, j as SelectNode, k as ParamNode, l as BinaryOpNode, m as DeleteNode, n as BasePrinter, o as ASTNode, p as ColumnRefNode, q as Primitive, r as PrintMode, s as ArrayExprNode, t as Dialect, u as CTENode, v as FrameKind, w as JoinNode, x as InNode, y as FrameSpec, z as createInsertNode } from "./_chunks/types.mjs";
+import { n as PgPrinter, t as pgDialect } from "./_chunks/pg.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 GeneratedAlways, C as time, D as varchar, E as uuid, F as Selectable, I as UpdateType, L as Updateable, M as Insertable, N as Nullable$1, O as ColumnType, P as SelectType, S as text$1, T as timestamptz, _ as jsonb, a as ColumnBuilder, b as serial, c as bigserial, d as char, f as date, g as json, h as integer, i as defineTable, j as InsertType, k as Generated, l as boolean, m as enumType, n as InferTable, o as ColumnDef, p as doublePrecision, r as TableDefinition, s as bigint, t as Nullable, u as bytea, v as numeric, w as timestamp, x as smallint, y as real } 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 function cast(expr: ExpressionNode, dataType: string): CastNode;
+declare function exists(query: SelectNode, negated?: boolean): ExistsNode;
+declare function not(operand: ExpressionNode): UnaryOpNode;
+declare class ASTTransformer {
+  transform(node: ASTNode): ASTNode;
+  transformSelect(node: SelectNode): SelectNode;
+  transformInsert(node: InsertNode): InsertNode;
+  transformUpdate(node: UpdateNode): UpdateNode;
+  transformDelete(node: DeleteNode): DeleteNode;
+  transformExpression(node: ExpressionNode): ExpressionNode;
+}
+interface ASTVisitor<R = void> {
+  visitSelect(node: SelectNode): R;
+  visitInsert(node: InsertNode): R;
+  visitUpdate(node: UpdateNode): R;
+  visitDelete(node: DeleteNode): 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 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;
+  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$1<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$1<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$1<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$1<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>;
+/**
+ * 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 & { [K in keyof DB[T]]: SelectType<DB[T][K]> }>;
+  /**
+   * 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$1<{ [K in keyof DB[T]]: SelectType<DB[T][K]> }>>;
+  /** 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$1<O> & { [K in keyof DB[T]]: SelectType<DB[T][K]> }>;
+  /** 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 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>;
+  /** 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 & keyof DB> };
+/**
+ * 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<{ [C in keyof DB[TB]]: SelectType<DB[TB][C]> }, K>>;
+  /**
+   * RETURNING all columns.
+   */
+  returningAll(): TypedInsertReturningBuilder<DB, TB, { [K in keyof DB[TB]]: SelectType<DB[TB][K]> }>;
+  /**
+   * 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>;
+  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-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<{ [C in keyof DB[TB]]: SelectType<DB[TB][C]> }, K>>;
+  /**
+   * RETURNING all columns.
+   */
+  returningAll(): TypedUpdateReturningBuilder<DB, TB, { [K in keyof DB[TB]]: SelectType<DB[TB][K]> }>;
+  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;
+}
+/**
+ * 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<{ [C in keyof DB[TB]]: SelectType<DB[TB][C]> }, K>>;
+  /**
+   * RETURNING all columns.
+   */
+  returningAll(): TypedDeleteReturningBuilder<DB, TB, { [K in keyof DB[TB]]: SelectType<DB[TB][K]> }>;
+  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;
+}
+/**
+ * Plugin interface for pamuk.
+ *
+ * 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 PamukPlugin {
+  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>[];
+}
+/**
+ * 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 PamukHooks {
+  /** 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 PamukHooks;
+/**
+ * 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: PamukHooks[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<PamukHooks[K]>): ReturnType<PamukHooks[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;
+}
+/**
+ * Extract the DB type from a tables config object.
+ */
+type InferDB<T extends Record<string, Record<string, ColumnBuilder<any, any, any>>>> = { [Table in keyof T]: { [Col in keyof T[Table]]: T[Table][Col] extends ColumnBuilder<infer S, infer I, infer U> ? ColumnType<S, I, U> : never } };
+interface PamukConfig<T extends Record<string, Record<string, ColumnBuilder<any, any, any>>>> {
+  dialect: Dialect;
+  tables: T;
+  plugins?: PamukPlugin[];
+}
+/**
+ * Create a fully typed pamuk instance. DB type is inferred automatically.
+ *
+ * ```ts
+ * const db = pamuk({
+ *   dialect: pgDialect(),
+ *   tables: {
+ *     users: { id: serial(), name: text().notNull() },
+ *   },
+ * });
+ *
+ * // Hook into the query lifecycle
+ * db.hook("select:before", (ctx) => {
+ *   console.log("Selecting from:", ctx.table);
+ * });
+ *
+ * db.selectFrom("users").select("id", "name")...
+ * ```
+ */
+declare function pamuk<T extends Record<string, Record<string, ColumnBuilder<any, any, any>>>>(config: PamukConfig<T>): Lale<InferDB<T>>;
+/**
+ * Core pamuk instance with hook system.
+ */
+declare class Pamuk<DB> {
+  private _dialect;
+  private _plugins;
+  private _hooks;
+  constructor(dialect: Dialect, plugins?: PamukPlugin[]);
+  /**
+   * 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: PamukHooks[K]): () => void;
+  selectFrom<T extends keyof DB & string>(table: T, alias?: string): TypedSelectBuilder<DB, T, { [K in keyof DB[T]]: SelectType<DB[T][K]> }>;
+  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>;
+  /**
+   * 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: PamukPlugin[]);
+  /** 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 PamukPlugin {
+  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 PamukPlugin {
+  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 PamukPlugin {
+  readonly name = "camel-case";
+  transformResult(rows: Record<string, unknown>[]): Record<string, unknown>[];
+}
+declare class PamukError extends Error {
+  constructor(message: string);
+}
+declare class InvalidExpressionError extends PamukError {
+  constructor(message: string);
+}
+declare class UnsupportedDialectFeatureError extends PamukError {
+  constructor(dialect: string, feature: string);
+}
+declare class EmptyQueryError extends PamukError {
+  constructor(queryType: string);
+}
+export { type ASTNode, ASTTransformer, type ASTVisitor, type ArrayExprNode, BasePrinter, type BetweenNode, type BinaryOpNode, type CTENode, CamelCasePlugin, type CaseNode, type CastNode, Col$1 as 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 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, MysqlPrinter, type Nullable, type OnConflictNode, type OrderByNode, type OrderDirection, Pamuk, type PamukConfig, PamukError, type PamukHooks, type PamukPlugin, type ParamNode, PgPrinter, PluginManager, type Primitive, type PrintMode, type Printer, type PrinterOptions, type RawNode, type SQLDialect, SelectBuilder, type SelectNode, type SelectType, type Selectable, type SetOperator, SoftDeletePlugin, SqlitePrinter, type StarNode, type SubqueryNode, type TableDefinition, type TableRefNode, TypedDeleteBuilder, TypedDeleteReturningBuilder, TypedInsertBuilder, TypedInsertReturningBuilder, TypedSelectBuilder, TypedUpdateBuilder, TypedUpdateReturningBuilder, type UnaryOpNode, UnsupportedDialectFeatureError, UpdateBuilder, type UpdateNode, type UpdateType, type Updateable, type WhereCallback, type WindowFunctionNode, WithSchemaPlugin, and, between, bigint, bigserial, binOp, boolean, bytea, cast, char, col, colAs, count, createDeleteNode, createInsertNode, 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, jsonb, like, lit, lt, lte, mysqlDialect, neq, not, numeric, or, pamuk, param, pgDialect, quoteIdentifier, quoteTableRef, raw, real, resetParams, select, serial, smallint, sqlFn, sqliteDialect, star, subquery, tableRef, text$1 as text, time, timestamp, timestamptz, unaryOp, update, uuid, val, varchar, visitNode };