@prisma/orm-family-sql 0.16.0-dev.36

package/dist/types-DIBA80mc-wf5wLmON.d.mts

@@ -0,0 +1,723 @@
+import { a as CodecRef$1 } from "./codec-types-MOaceoPi-C5eL2sao.mjs";
+import { t as SqlLoweringSpec } from "./index-BgaTJRxj.mjs";
+import { ParamSpec } from "@prisma/orm-framework/operations";
+//#region ../../../2-sql/4-lanes/relational-core/dist/types-DIBA80mc.d.mts
+//#region src/ast/json-value-projection.d.ts
+declare abstract class JsonValueProjection {
+  abstract readonly kind: string;
+  readonly value: ProjectionExpr;
+  protected constructor(value: ProjectionExpr);
+  abstract accept<R>(visitor: JsonValueProjectionVisitor<R>): R;
+  abstract rewrite(rewriter: ExpressionRewriter): AnyJsonValueProjection;
+  fold<T>(folder: ExpressionFolder<T>): T;
+  collectColumnRefs(): ColumnRef[];
+  collectParamRefs(): AnyParamRef[];
+  protected freeze(): void;
+}
+interface JsonValueProjectionVisitor<R> {
+  codec(projection: CodecJsonValueProjection): R;
+  native(projection: NativeJsonValueProjection): R;
+  document(projection: JsonDocumentProjection): R;
+}
+declare class CodecJsonValueProjection extends JsonValueProjection {
+  readonly kind: "codec";
+  readonly codec: CodecRef$1;
+  constructor(value: ProjectionExpr, codec: CodecRef$1);
+  accept<R>(visitor: JsonValueProjectionVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): CodecJsonValueProjection;
+}
+declare class NativeJsonValueProjection extends JsonValueProjection {
+  readonly kind: "native";
+  constructor(value: ProjectionExpr);
+  accept<R>(visitor: JsonValueProjectionVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): NativeJsonValueProjection;
+}
+declare class JsonDocumentProjection extends JsonValueProjection {
+  readonly kind: "document";
+  constructor(value: ProjectionExpr);
+  accept<R>(visitor: JsonValueProjectionVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): JsonDocumentProjection;
+}
+type AnyJsonValueProjection = CodecJsonValueProjection | NativeJsonValueProjection | JsonDocumentProjection;
+//#endregion
+//#region src/ast/types.d.ts
+type Direction = 'asc' | 'desc';
+type BinaryOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'like' | 'in' | 'notIn';
+type AggregateCountFn = 'count';
+type AggregateOpFn = 'sum' | 'avg' | 'min' | 'max';
+type AggregateFn = AggregateCountFn | AggregateOpFn;
+/**
+ * Window function names. Currently only `row_number` is wired up — added
+ * to support `ROW_NUMBER() OVER (PARTITION BY ... ORDER BY ...) = 1`
+ * lowering for `.distinct(cols)` semantics in the SQL ORM client. `rank`
+ * and `dense_rank` are reserved here so future additions don't churn the
+ * type; renderers only need to dispatch on the function name string.
+ */
+type WindowFn = 'row_number' | 'rank' | 'dense_rank';
+/** Scalar JS values that map directly to a SQL wire type. Values outside this set must be routed through `param(value, { codecId })` to declare the target codec explicitly. */
+type RawSqlLiteral = number | bigint | string | boolean | Uint8Array;
+interface ExpressionSource {
+  toExpr(): AnyExpression;
+}
+interface ExpressionRewriter {
+  columnRef?(expr: ColumnRef): AnyExpression;
+  identifierRef?(expr: IdentifierRef): AnyExpression;
+  paramRef?(expr: ParamRef): ParamRef | LiteralExpr;
+  preparedParamRef?(expr: PreparedParamRef): PreparedParamRef;
+  literal?(expr: LiteralExpr): LiteralExpr;
+  list?(expr: ListExpression): ListExpression | LiteralExpr;
+  select?(ast: SelectAst): SelectAst;
+  rawExpr?(expr: RawExpr): AnyExpression;
+}
+interface AstRewriter extends ExpressionRewriter {
+  tableSource?(source: TableSource): TableSource;
+  eqColJoinOn?(on: EqColJoinOn): EqColJoinOn | AnyExpression;
+}
+interface ExprVisitor<R> {
+  columnRef(expr: ColumnRef): R;
+  identifierRef(expr: IdentifierRef): R;
+  subquery(expr: SubqueryExpr): R;
+  operation(expr: OperationExpr): R;
+  aggregate(expr: AggregateExpr): R;
+  windowFunc(expr: WindowFuncExpr): R;
+  functionCall(expr: FunctionCallExpr): R;
+  cast(expr: CastExpr): R;
+  case(expr: CaseExpr): R;
+  jsonObject(expr: JsonObjectExpr): R;
+  jsonArrayAgg(expr: JsonArrayAggExpr): R;
+  binary(expr: BinaryExpr): R;
+  and(expr: AndExpr): R;
+  or(expr: OrExpr): R;
+  exists(expr: ExistsExpr): R;
+  nullCheck(expr: NullCheckExpr): R;
+  not(expr: NotExpr): R;
+  literal(expr: LiteralExpr): R;
+  param(expr: ParamRef): R;
+  preparedParam(expr: PreparedParamRef): R;
+  list(expr: ListExpression): R;
+  rawExpr(expr: RawExpr): R;
+}
+interface ExpressionFolder<T> {
+  empty: T;
+  combine(a: T, b: T): T;
+  isAbsorbing?(value: T): boolean;
+  columnRef?(expr: ColumnRef): T;
+  identifierRef?(expr: IdentifierRef): T;
+  paramRef?(expr: ParamRef): T;
+  preparedParamRef?(expr: PreparedParamRef): T;
+  literal?(expr: LiteralExpr): T;
+  list?(expr: ListExpression): T;
+  select?(ast: SelectAst): T;
+  rawExpr?(expr: RawExpr): T;
+}
+type ProjectionExpr = AnyExpression;
+type InsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr | RawExpr;
+type JoinOnExpr = EqColJoinOn | AnyExpression;
+type WhereArg = AnyExpression | ToWhereExpr;
+type JsonObjectEntry = {
+  readonly key: string;
+  readonly value: AnyJsonValueProjection;
+};
+declare abstract class AstNode {
+  abstract readonly kind: string;
+  protected freeze(): void;
+}
+declare abstract class QueryAst extends AstNode {
+  abstract collectParamRefs(): AnyParamRef[];
+  abstract toQueryAst(): AnyQueryAst;
+}
+declare abstract class FromSource extends AstNode {
+  abstract rewrite(rewriter: AstRewriter): AnyFromSource;
+  abstract toFromSource(): AnyFromSource;
+}
+declare abstract class Expression extends AstNode implements ExpressionSource {
+  #private;
+  abstract accept<R>(visitor: ExprVisitor<R>): R;
+  abstract rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  abstract fold<T>(folder: ExpressionFolder<T>): T;
+  collectColumnRefs(): ColumnRef[];
+  collectParamRefs(): AnyParamRef[];
+  baseColumnRef(): ColumnRef;
+  toExpr(): AnyExpression;
+  not(): NotExpr;
+}
+declare class TableSource extends FromSource {
+  readonly kind: "table-source";
+  readonly name: string;
+  readonly alias: string | undefined;
+  /**
+   * Resolved storage namespace coordinate for this table, stamped when the
+   * table proxy constructs the AST. Renderers qualify via the namespace
+   * concretion's `qualifyTable()` using this id — never by re-resolving the
+   * bare table name at render time.
+   */
+  readonly namespaceId: string | undefined;
+  protected constructor(name: string, alias?: string, namespaceId?: string);
+  static named(name: string, alias?: string, namespaceId?: string): TableSource;
+  rewrite(rewriter: AstRewriter): AnyFromSource;
+  toFromSource(): AnyFromSource;
+}
+interface TableRef {
+  readonly name: string;
+  readonly alias?: string;
+}
+declare class DerivedTableSource extends FromSource {
+  readonly kind: "derived-table-source";
+  readonly alias: string;
+  readonly query: SelectAst;
+  constructor(alias: string, query: SelectAst);
+  static as(alias: string, query: SelectAst): DerivedTableSource;
+  rewrite(rewriter: AstRewriter): AnyFromSource;
+  toFromSource(): AnyFromSource;
+}
+interface FunctionSourceAlias {
+  readonly alias: string;
+  readonly columnAliases?: ReadonlyArray<string>;
+}
+declare class FunctionSource extends FromSource {
+  #private;
+  readonly kind: "function-source";
+  readonly fn: string;
+  readonly args: ReadonlyArray<AnyExpression>;
+  readonly alias: string | undefined;
+  readonly columnAliases: ReadonlyArray<string> | undefined;
+  readonly ordinality: boolean;
+  protected constructor(fn: string, args: ReadonlyArray<AnyExpression>, alias?: FunctionSourceAlias, ordinality?: boolean);
+  static of(fn: string, args: ReadonlyArray<AnyExpression>, alias?: FunctionSourceAlias): FunctionSource;
+  withOrdinality(): FunctionSource;
+  rewrite(rewriter: AstRewriter): AnyFromSource;
+  toFromSource(): AnyFromSource;
+}
+declare class ColumnRef extends Expression {
+  readonly kind: "column-ref";
+  readonly table: string;
+  readonly column: string;
+  constructor(table: string, column: string);
+  static of(table: string, column: string): ColumnRef;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+  baseColumnRef(): ColumnRef;
+}
+declare class IdentifierRef extends Expression {
+  readonly kind: "identifier-ref";
+  readonly name: string;
+  constructor(name: string);
+  static of(name: string): IdentifierRef;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class ParamRef extends Expression {
+  readonly kind: "param-ref";
+  readonly value: unknown;
+  readonly name: string | undefined;
+  /**
+   * Codec identity carried by every column-bound `ParamRef`. The encode-side dispatch path materialises the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation on `(codecId, canonicalize(typeParams))` keeps repeated lookups for the same logical column on one shared {@link Codec}.
+   *
+   * `codec` may be `undefined` for `ParamRef`s constructed without a column-bound site (literals, transient builder state); the runtime treats those as untyped passthroughs.
+   */
+  readonly codec: CodecRef$1 | undefined;
+  constructor(value: unknown, options?: {
+    name?: string;
+    codec?: CodecRef$1;
+  });
+  static of(value: unknown, options?: {
+    name?: string;
+    codec?: CodecRef$1;
+  }): ParamRef;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+/**
+ * Bind-site placeholder: occupies the same positions as `ParamRef` in the
+ * AST, but carries no value — the value is supplied per-execute by the
+ * `PreparedStatement.execute(params)` caller and matched to this node by
+ * `name`.
+ */
+declare class PreparedParamRef extends Expression {
+  readonly kind: "prepared-param-ref";
+  readonly name: string;
+  readonly codec: CodecRef$1;
+  constructor(name: string, codec: CodecRef$1);
+  static of(name: string, codec: CodecRef$1): PreparedParamRef;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class DefaultValueExpr extends AstNode {
+  readonly kind: "default-value";
+  constructor();
+}
+declare class LiteralExpr extends Expression {
+  readonly kind: "literal";
+  readonly value: unknown;
+  constructor(value: unknown);
+  static of(value: unknown): LiteralExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class SubqueryExpr extends Expression {
+  readonly kind: "subquery";
+  readonly query: SelectAst;
+  constructor(query: SelectAst);
+  static of(query: SelectAst): SubqueryExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class OperationExpr extends Expression {
+  readonly kind: "operation";
+  readonly method: string;
+  readonly self: AnyExpression;
+  readonly args: ReadonlyArray<AnyExpression | ParamRef | LiteralExpr>;
+  readonly returns: ParamSpec;
+  readonly lowering: SqlLoweringSpec;
+  constructor(options: {
+    readonly method: string;
+    readonly self: AnyExpression;
+    readonly args: ReadonlyArray<AnyExpression | ParamRef | LiteralExpr> | undefined;
+    readonly returns: ParamSpec;
+    readonly lowering: SqlLoweringSpec;
+  });
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+  baseColumnRef(): ColumnRef;
+}
+declare class RawExpr extends Expression {
+  readonly kind: "raw-expr";
+  readonly parts: ReadonlyArray<string | AnyExpression>;
+  readonly returns: ParamSpec;
+  constructor(options: {
+    readonly parts: ReadonlyArray<string | AnyExpression>;
+    readonly returns: ParamSpec;
+  });
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class AggregateExpr extends Expression {
+  readonly kind: "aggregate";
+  readonly fn: AggregateFn;
+  readonly expr: AnyExpression | undefined;
+  constructor(fn: AggregateFn, expr?: AnyExpression);
+  static count(expr?: AnyExpression): AggregateExpr;
+  static sum(expr: AnyExpression): AggregateExpr;
+  static avg(expr: AnyExpression): AggregateExpr;
+  static min(expr: AnyExpression): AggregateExpr;
+  static max(expr: AnyExpression): AggregateExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+/**
+ * Window function call: `fn(args) OVER (PARTITION BY ... ORDER BY ...)`.
+ *
+ * Both `partitionBy` and `orderBy` are optional; an empty `OVER ()`
+ * clause is legal SQL but rarely useful. For `ROW_NUMBER`, `RANK`, and
+ * `DENSE_RANK` the standard mandates an `ORDER BY` for deterministic
+ * results — callers are expected to provide one, but the AST does not
+ * enforce it.
+ *
+ * The `args` slot exists for future window function additions that take
+ * arguments (e.g. `COUNT(*) OVER`, `SUM(x) OVER`); `ROW_NUMBER` and the
+ * other ranking functions take no arguments.
+ */
+declare class WindowFuncExpr extends Expression {
+  readonly kind: "window-func";
+  readonly fn: WindowFn;
+  readonly args: ReadonlyArray<AnyExpression>;
+  readonly partitionBy: ReadonlyArray<AnyExpression> | undefined;
+  readonly orderBy: ReadonlyArray<OrderByItem> | undefined;
+  constructor(options: {
+    readonly fn: WindowFn;
+    readonly args?: ReadonlyArray<AnyExpression>;
+    readonly partitionBy?: ReadonlyArray<AnyExpression>;
+    readonly orderBy?: ReadonlyArray<OrderByItem>;
+  });
+  static rowNumber(options: {
+    readonly partitionBy?: ReadonlyArray<AnyExpression>;
+    readonly orderBy?: ReadonlyArray<OrderByItem>;
+  }): WindowFuncExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class FunctionCallExpr extends Expression {
+  readonly kind: "function-call";
+  readonly fn: string;
+  readonly args: ReadonlyArray<AnyExpression>;
+  constructor(fn: string, args: ReadonlyArray<AnyExpression>);
+  static of(fn: string, args: ReadonlyArray<AnyExpression>): FunctionCallExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class CastExpr extends Expression {
+  readonly kind: "cast";
+  readonly expr: AnyExpression;
+  readonly targetType: string;
+  constructor(expr: AnyExpression, targetType: string);
+  static as(expr: AnyExpression, targetType: string): CastExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+interface CaseBranch {
+  readonly condition: AnyExpression;
+  readonly value: AnyExpression;
+}
+declare class CaseExpr extends Expression {
+  readonly kind: "case";
+  readonly branches: ReadonlyArray<Readonly<CaseBranch>>;
+  readonly elseExpr: AnyExpression | undefined;
+  constructor(branches: ReadonlyArray<CaseBranch>, elseExpr?: AnyExpression);
+  static of(branches: ReadonlyArray<CaseBranch>, elseExpr?: AnyExpression): CaseExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class JsonObjectExpr extends Expression {
+  readonly kind: "json-object";
+  readonly entries: ReadonlyArray<JsonObjectEntry>;
+  constructor(entries: ReadonlyArray<JsonObjectEntry>);
+  static entry(key: string, value: AnyJsonValueProjection): JsonObjectEntry;
+  static fromEntries(entries: ReadonlyArray<JsonObjectEntry>): JsonObjectExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class OrderByItem extends AstNode {
+  readonly kind: "order-by-item";
+  readonly expr: AnyExpression;
+  readonly dir: Direction;
+  constructor(expr: AnyExpression, dir: Direction);
+  static asc(expr: AnyExpression): OrderByItem;
+  static desc(expr: AnyExpression): OrderByItem;
+  rewrite(rewriter: ExpressionRewriter): OrderByItem;
+  /**
+   * A new frozen item with the sort direction flipped and `expr` unchanged.
+   * Integrations that own pagination (e.g. backward cursor pagination) use
+   * this to reverse a user's sort order without reaching into the AST.
+   */
+  reverse(): OrderByItem;
+}
+declare class JsonArrayAggExpr extends Expression {
+  readonly kind: "json-array-agg";
+  readonly expr: AnyJsonValueProjection;
+  readonly onEmpty: 'null' | 'emptyArray';
+  readonly orderBy: ReadonlyArray<OrderByItem> | undefined;
+  constructor(expr: AnyJsonValueProjection, onEmpty?: 'null' | 'emptyArray', orderBy?: ReadonlyArray<OrderByItem>);
+  static of(expr: AnyJsonValueProjection, onEmpty?: 'null' | 'emptyArray', orderBy?: ReadonlyArray<OrderByItem>): JsonArrayAggExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class ListExpression extends Expression {
+  readonly kind: "list";
+  readonly values: ReadonlyArray<AnyExpression>;
+  constructor(values: ReadonlyArray<AnyExpression>);
+  static of(values: ReadonlyArray<AnyExpression>): ListExpression;
+  static fromValues(values: ReadonlyArray<unknown>): ListExpression;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class BinaryExpr extends Expression {
+  readonly kind: "binary";
+  readonly op: BinaryOp;
+  readonly left: AnyExpression;
+  readonly right: AnyExpression;
+  constructor(op: BinaryOp, left: AnyExpression, right: AnyExpression);
+  static eq(left: AnyExpression, right: AnyExpression): BinaryExpr;
+  static neq(left: AnyExpression, right: AnyExpression): BinaryExpr;
+  static gt(left: AnyExpression, right: AnyExpression): BinaryExpr;
+  static lt(left: AnyExpression, right: AnyExpression): BinaryExpr;
+  static gte(left: AnyExpression, right: AnyExpression): BinaryExpr;
+  static lte(left: AnyExpression, right: AnyExpression): BinaryExpr;
+  static like(left: AnyExpression, right: AnyExpression): BinaryExpr;
+  static in(left: AnyExpression, right: AnyExpression): BinaryExpr;
+  static notIn(left: AnyExpression, right: AnyExpression): BinaryExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class AndExpr extends Expression {
+  readonly kind: "and";
+  readonly exprs: ReadonlyArray<AnyExpression>;
+  constructor(exprs: ReadonlyArray<AnyExpression>);
+  static of(exprs: ReadonlyArray<AnyExpression>): AndExpr;
+  static true(): AndExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class OrExpr extends Expression {
+  readonly kind: "or";
+  readonly exprs: ReadonlyArray<AnyExpression>;
+  constructor(exprs: ReadonlyArray<AnyExpression>);
+  static of(exprs: ReadonlyArray<AnyExpression>): OrExpr;
+  static false(): OrExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class ExistsExpr extends Expression {
+  readonly kind: "exists";
+  readonly notExists: boolean;
+  readonly subquery: SelectAst;
+  constructor(subquery: SelectAst, notExists?: boolean);
+  static exists(subquery: SelectAst): ExistsExpr;
+  static notExists(subquery: SelectAst): ExistsExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class NullCheckExpr extends Expression {
+  readonly kind: "null-check";
+  readonly expr: AnyExpression;
+  readonly isNull: boolean;
+  constructor(expr: AnyExpression, isNull: boolean);
+  static isNull(expr: AnyExpression): NullCheckExpr;
+  static isNotNull(expr: AnyExpression): NullCheckExpr;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class NotExpr extends Expression {
+  readonly kind: "not";
+  readonly expr: AnyExpression;
+  constructor(expr: AnyExpression);
+  toWhereExpr(): AnyExpression;
+  accept<R>(visitor: ExprVisitor<R>): R;
+  rewrite(rewriter: ExpressionRewriter): AnyExpression;
+  fold<T>(folder: ExpressionFolder<T>): T;
+}
+declare class EqColJoinOn extends AstNode {
+  readonly kind: "eq-col-join-on";
+  readonly left: ColumnRef;
+  readonly right: ColumnRef;
+  constructor(left: ColumnRef, right: ColumnRef);
+  static of(left: ColumnRef, right: ColumnRef): EqColJoinOn;
+  rewrite(rewriter: AstRewriter): EqColJoinOn | AnyExpression;
+}
+declare class JoinAst extends AstNode {
+  readonly kind: "join";
+  readonly joinType: 'inner' | 'left' | 'right' | 'full';
+  readonly source: AnyFromSource;
+  readonly lateral: boolean;
+  readonly on: JoinOnExpr;
+  constructor(joinType: 'inner' | 'left' | 'right' | 'full', source: AnyFromSource, on: JoinOnExpr, lateral?: boolean);
+  static inner(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst;
+  static left(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst;
+  static right(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst;
+  static full(source: AnyFromSource, on: JoinOnExpr, lateral?: boolean): JoinAst;
+  rewrite(rewriter: AstRewriter): JoinAst;
+}
+declare class ProjectionItem extends AstNode {
+  readonly kind: "projection-item";
+  readonly alias: string;
+  readonly expr: ProjectionExpr;
+  /**
+   * Codec identity for any known projected result, whether read directly from a contract column or forwarded through a query wrapper. Decode-side dispatch resolves the per-instance codec through `contractCodecs.forCodecRef(codec)` — content-keyed memoisation collapses repeated lookups for the same logical result onto one shared {@link Codec}.
+   *
+   * Stays `undefined` only when the projected result's codec is unknown, such as computed expressions, subqueries, or raw aliases whose decoded type the runtime cannot infer.
+   */
+  readonly codec: CodecRef$1 | undefined;
+  constructor(alias: string, expr: ProjectionExpr, codec?: CodecRef$1);
+  static of(alias: string, expr: ProjectionExpr, codec?: CodecRef$1): ProjectionItem;
+  withCodec(codec: CodecRef$1 | undefined): ProjectionItem;
+}
+type LimitOffsetValue = number | AnyExpression;
+interface SelectAstOptions {
+  readonly from?: AnyFromSource;
+  readonly joins: ReadonlyArray<JoinAst> | undefined;
+  readonly projection: ReadonlyArray<ProjectionItem>;
+  readonly where: AnyExpression | undefined;
+  readonly orderBy: ReadonlyArray<OrderByItem> | undefined;
+  readonly distinct: true | undefined;
+  readonly distinctOn: ReadonlyArray<AnyExpression> | undefined;
+  readonly groupBy: ReadonlyArray<AnyExpression> | undefined;
+  readonly having: AnyExpression | undefined;
+  readonly limit: LimitOffsetValue | undefined;
+  readonly offset: LimitOffsetValue | undefined;
+  readonly selectAllIntent: {
+    readonly table?: string;
+  } | undefined;
+}
+declare class SelectAst extends QueryAst {
+  readonly kind: "select";
+  readonly from: AnyFromSource | undefined;
+  readonly joins: ReadonlyArray<JoinAst> | undefined;
+  readonly projection: ReadonlyArray<ProjectionItem>;
+  readonly where: AnyExpression | undefined;
+  readonly orderBy: ReadonlyArray<OrderByItem> | undefined;
+  readonly distinct: true | undefined;
+  readonly distinctOn: ReadonlyArray<AnyExpression> | undefined;
+  readonly groupBy: ReadonlyArray<AnyExpression> | undefined;
+  readonly having: AnyExpression | undefined;
+  readonly limit: LimitOffsetValue | undefined;
+  readonly offset: LimitOffsetValue | undefined;
+  readonly selectAllIntent: {
+    readonly table?: string;
+  } | undefined;
+  constructor(options: SelectAstOptions);
+  static from(from: AnyFromSource): SelectAst;
+  static noFrom(): SelectAst;
+  private toOptions;
+  withFrom(from: AnyFromSource): SelectAst;
+  withJoins(joins: ReadonlyArray<JoinAst>): SelectAst;
+  withProjection(projection: ReadonlyArray<ProjectionItem>): SelectAst;
+  addProjection(alias: string, expr: ProjectionExpr): SelectAst;
+  withWhere(where: AnyExpression | undefined): SelectAst;
+  withOrderBy(orderBy: ReadonlyArray<OrderByItem>): SelectAst;
+  withDistinct(enabled?: boolean): SelectAst;
+  withDistinctOn(distinctOn: ReadonlyArray<AnyExpression>): SelectAst;
+  withGroupBy(groupBy: ReadonlyArray<AnyExpression>): SelectAst;
+  withHaving(having: AnyExpression | undefined): SelectAst;
+  withLimit(limit: LimitOffsetValue | undefined): SelectAst;
+  withOffset(offset: LimitOffsetValue | undefined): SelectAst;
+  withSelectAllIntent(selectAllIntent: {
+    readonly table?: string;
+  } | undefined): SelectAst;
+  rewrite(rewriter: AstRewriter): SelectAst;
+  collectColumnRefs(): ColumnRef[];
+  collectParamRefs(): AnyParamRef[];
+  toQueryAst(): AnyQueryAst;
+}
+declare abstract class InsertOnConflictAction extends AstNode {
+  abstract toInsertOnConflictAction(): AnyInsertOnConflictAction;
+}
+declare class DoNothingConflictAction extends InsertOnConflictAction {
+  readonly kind: "do-nothing";
+  constructor();
+  toInsertOnConflictAction(): AnyInsertOnConflictAction;
+}
+declare class DoUpdateSetConflictAction extends InsertOnConflictAction {
+  readonly kind: "do-update-set";
+  readonly set: Readonly<Record<string, AnyExpression>>;
+  constructor(set: Readonly<Record<string, AnyExpression>>);
+  toInsertOnConflictAction(): AnyInsertOnConflictAction;
+}
+declare class InsertOnConflict extends AstNode {
+  readonly kind: "insert-on-conflict";
+  readonly columns: ReadonlyArray<ColumnRef>;
+  readonly action: AnyInsertOnConflictAction;
+  constructor(columns: ReadonlyArray<ColumnRef>, action: AnyInsertOnConflictAction);
+  static on(columns: ReadonlyArray<ColumnRef>): InsertOnConflict;
+  doNothing(): InsertOnConflict;
+  doUpdateSet(set: Readonly<Record<string, AnyExpression>>): InsertOnConflict;
+}
+declare class InsertAst extends QueryAst {
+  readonly kind: "insert";
+  readonly table: TableSource;
+  readonly rows: ReadonlyArray<Readonly<Record<string, InsertValue>>>;
+  readonly onConflict: InsertOnConflict | undefined;
+  readonly returning: ReadonlyArray<ProjectionItem> | undefined;
+  constructor(table: TableSource, rows?: ReadonlyArray<Record<string, InsertValue>>, onConflict?: InsertOnConflict, returning?: ReadonlyArray<ProjectionItem>);
+  static into(table: TableSource): InsertAst;
+  withRows(rows: ReadonlyArray<Record<string, InsertValue>>): InsertAst;
+  withReturning(returning: ReadonlyArray<ProjectionItem> | undefined): InsertAst;
+  withOnConflict(onConflict: InsertOnConflict | undefined): InsertAst;
+  rewrite(rewriter: AstRewriter): InsertAst;
+  collectParamRefs(): AnyParamRef[];
+  toQueryAst(): AnyQueryAst;
+}
+declare class UpdateAst extends QueryAst {
+  readonly kind: "update";
+  readonly table: TableSource;
+  readonly set: Readonly<Record<string, AnyExpression>>;
+  readonly where: AnyExpression | undefined;
+  readonly returning: ReadonlyArray<ProjectionItem> | undefined;
+  constructor(table: TableSource, set?: Readonly<Record<string, AnyExpression>>, where?: AnyExpression, returning?: ReadonlyArray<ProjectionItem>);
+  static table(table: TableSource): UpdateAst;
+  withSet(set: Readonly<Record<string, AnyExpression>>): UpdateAst;
+  withWhere(where: AnyExpression | undefined): UpdateAst;
+  withReturning(returning: ReadonlyArray<ProjectionItem> | undefined): UpdateAst;
+  rewrite(rewriter: AstRewriter): UpdateAst;
+  collectParamRefs(): AnyParamRef[];
+  toQueryAst(): AnyQueryAst;
+}
+declare class DeleteAst extends QueryAst {
+  readonly kind: "delete";
+  readonly table: TableSource;
+  readonly where: AnyExpression | undefined;
+  readonly returning: ReadonlyArray<ProjectionItem> | undefined;
+  constructor(table: TableSource, where?: AnyExpression, returning?: ReadonlyArray<ProjectionItem>);
+  static from(table: TableSource): DeleteAst;
+  withWhere(where: AnyExpression | undefined): DeleteAst;
+  withReturning(returning: ReadonlyArray<ProjectionItem> | undefined): DeleteAst;
+  rewrite(rewriter: AstRewriter): DeleteAst;
+  collectParamRefs(): AnyParamRef[];
+  toQueryAst(): AnyQueryAst;
+}
+/**
+ * Raw-SQL query AST node carrying interpolated parameter / expression nodes
+ * embedded inside literal SQL fragments.
+ *
+ * `fragments` and `args` are interleaved during lowering:
+ * `fragments[0] + lower(args[0]) + fragments[1] + ... + fragments[n]`.
+ * Construction enforces `fragments.length === args.length + 1`.
+ *
+ * Extends {@link QueryAst} (whole-query AST, not a sub-expression).
+ * Construction does not validate that each arg is a `ParamRef` /
+ * `AnyExpression`: the type system already rejects bare values because
+ * `args` is typed `readonly AnyExpression[]`. The user-facing `raw\`...\``
+ * factory (separate `sql-raw-factory` component) layers stricter
+ * type-level rejection on top of this AST node.
+ */
+declare class RawSqlExpr extends QueryAst {
+  readonly kind: "raw-sql";
+  readonly fragments: readonly string[];
+  readonly args: readonly AnyExpression[];
+  constructor(fragments: readonly string[], args: readonly AnyExpression[]);
+  static of(fragments: readonly string[], args: readonly AnyExpression[]): RawSqlExpr;
+  collectParamRefs(): AnyParamRef[];
+  toQueryAst(): AnyQueryAst;
+}
+type AnyQueryAst = SelectAst | InsertAst | UpdateAst | DeleteAst | RawSqlExpr;
+type AnyFromSource = TableSource | DerivedTableSource | FunctionSource;
+type AnyExpression = ColumnRef | IdentifierRef | ParamRef | PreparedParamRef | LiteralExpr | SubqueryExpr | OperationExpr | AggregateExpr | WindowFuncExpr | FunctionCallExpr | CastExpr | CaseExpr | JsonObjectExpr | JsonArrayAggExpr | ListExpression | BinaryExpr | AndExpr | OrExpr | ExistsExpr | NullCheckExpr | NotExpr | RawExpr;
+type AnyParamRef = ParamRef | PreparedParamRef;
+type AnyInsertOnConflictAction = DoNothingConflictAction | DoUpdateSetConflictAction;
+type AnyInsertValue = ColumnRef | ParamRef | PreparedParamRef | DefaultValueExpr | RawExpr;
+type AnyOperationArg = AnyExpression | ParamRef | PreparedParamRef | LiteralExpr;
+declare const queryAstKinds: ReadonlySet<string>;
+declare const whereExprKinds: ReadonlySet<string>;
+declare function isQueryAst(value: unknown): value is AnyQueryAst;
+declare function isWhereExpr(value: unknown): value is AnyExpression;
+interface ToWhereExpr {
+  toWhereExpr(): AnyExpression;
+}
+/**
+ * One positional slot of a lowered SQL statement.
+ *
+ * - `literal` — a value baked into the AST; passes through to the driver.
+ * - `bind` — a `PreparedParamRef` placeholder; the runtime resolves the
+ *   value from the per-execute `userParams[name]` before calling the driver.
+ *
+ * The same `name` may legitimately appear in multiple `bind` slots when a
+ * renderer does not dedupe `PreparedParamRef` occurrences (e.g. SQLite's
+ * positional `?` walker calls `ast.collectParamRefs()` directly rather than
+ * `collectOrderedParamRefs`); resolution-by-name handles that case
+ * correctly. See `collectOrderedParamRefs` in `./util` for the dedupe
+ * contract used by Postgres' `$N` renderer.
+ */
+type LoweredParam = {
+  readonly kind: 'literal';
+  readonly value: unknown;
+} | {
+  readonly kind: 'bind';
+  readonly name: string;
+};
+interface LoweredStatement {
+  readonly sql: string;
+  readonly params: readonly LoweredParam[];
+  readonly annotations?: Record<string, unknown>;
+}
+//#endregion
+export { NativeJsonValueProjection as $, ExprVisitor as A, InsertValue as B, DeleteAst as C, isWhereExpr as Ct, DoUpdateSetConflictAction as D, DoNothingConflictAction as E, FunctionSource as F, JsonObjectEntry as G, JoinOnExpr as H, FunctionSourceAlias as I, LimitOffsetValue as J, JsonObjectExpr as K, IdentifierRef as L, ExpressionRewriter as M, ExpressionSource as N, EqColJoinOn as O, FunctionCallExpr as P, LoweredStatement as Q, InsertAst as R, DefaultValueExpr as S, isQueryAst as St, Direction as T, whereExprKinds as Tt, JsonArrayAggExpr as U, JoinAst as V, JsonDocumentProjection as W, LiteralExpr as X, ListExpression as Y, LoweredParam as Z, CaseBranch as _, ToWhereExpr as _t, AndExpr as a, ParamRef as at, CodecJsonValueProjection as b, WindowFn as bt, AnyInsertOnConflictAction as c, ProjectionItem as ct, AnyOperationArg as d, RawSqlLiteral as dt, NotExpr as et, AnyParamRef as f, SelectAst as ft, BinaryOp as g, TableSource as gt, BinaryExpr as h, TableRef as ht, AggregateOpFn as i, OrderByItem as it, ExpressionFolder as j, ExistsExpr as k, AnyInsertValue as l, RawExpr as lt, AstRewriter as m, SubqueryExpr as mt, AggregateExpr as n, OperationExpr as nt, AnyExpression as o, PreparedParamRef as ot, AnyQueryAst as p, SelectAstOptions as pt, JsonValueProjectionVisitor as q, AggregateFn as r, OrExpr as rt, AnyFromSource as s, ProjectionExpr as st, AggregateCountFn as t, NullCheckExpr as tt, AnyJsonValueProjection as u, RawSqlExpr as ut, CaseExpr as v, UpdateAst as vt, DerivedTableSource as w, queryAstKinds as wt, ColumnRef as x, WindowFuncExpr as xt, CastExpr as y, WhereArg as yt, InsertOnConflict as z };
+//# sourceMappingURL=types-DIBA80mc-wf5wLmON.d.mts.map