qubu 0.0.0 → 0.3.3

package/dist/types-4Q076HKo.d.mts

@@ -0,0 +1,3636 @@
+//#region src/core/sql-types.d.ts
+/** A portable or dialect-specific SQL value domain. */
+interface SqlSemanticType<TName extends string = string> {
+  readonly sqlType: TName;
+}
+/** Marker for extensions whose SQL domain has not been declared. */
+type SqlUnknown = SqlSemanticType<'unknown'> & {
+  readonly sqlUnknown: true;
+};
+/** SQL domains accepted by text operations and the text equality group. */
+interface SqlTextLike extends SqlEqualityComparable<'text'> {
+  readonly sqlTextLike: true;
+}
+/** SQL domains accepted by numeric operations. */
+interface SqlNumericLike {
+  readonly sqlNumericLike: true;
+}
+/** SQL domains with a portable ordering relation. */
+interface SqlOrderable<TGroup = unknown> {
+  readonly sqlOrderGroup: TGroup;
+}
+/**
+ * SQL domains that can be compared for equality with the same compatibility
+ * group. Dialect extensions can share a group with a portable domain.
+ */
+interface SqlEqualityComparable<TGroup = unknown> {
+  readonly sqlEqualityGroup: TGroup;
+}
+/** Portable text domain with text, ordering, and equality capabilities. */
+type SqlText = SqlSemanticType<'text'> & SqlTextLike & SqlOrderable<'text'> & SqlEqualityComparable<'text'>;
+/** Portable UUID domain; equality-capable but deliberately not text-like. */
+type SqlUuid = SqlSemanticType<'uuid'> & SqlEqualityComparable<'uuid'>;
+/** Portable integer domain in the shared numeric compatibility groups. */
+type SqlInteger = SqlSemanticType<'integer'> & SqlNumericLike & SqlOrderable<'numeric'> & SqlEqualityComparable<'numeric'>;
+/** Portable decimal domain in the shared numeric compatibility groups. */
+type SqlDecimal = SqlSemanticType<'decimal'> & SqlNumericLike & SqlOrderable<'numeric'> & SqlEqualityComparable<'numeric'>;
+/** Portable boolean domain with equality comparison. */
+type SqlBoolean = SqlSemanticType<'boolean'> & SqlEqualityComparable<'boolean'>;
+/** Portable date domain with date-specific equality and ordering groups. */
+type SqlDate = SqlSemanticType<'date'> & SqlOrderable<'date'> & SqlEqualityComparable<'date'>;
+/** Portable timestamp domain with timestamp-specific comparison groups. */
+type SqlTimestamp = SqlSemanticType<'timestamp'> & SqlOrderable<'timestamp'> & SqlEqualityComparable<'timestamp'>;
+/** Portable JSON domain retaining its decoded application value type. */
+type SqlJson<TValue = unknown> = SqlSemanticType<'json'> & {
+  readonly sqlJsonValue?: TValue;
+};
+/** Portable bigint domain in the shared numeric compatibility groups. */
+type SqlBigInt = SqlSemanticType<'bigint'> & SqlNumericLike & SqlOrderable<'numeric'> & SqlEqualityComparable<'numeric'>;
+/** Portable binary domain with equality comparison. */
+type SqlBinary = SqlSemanticType<'binary'> & SqlEqualityComparable<'binary'>;
+/** Any declared SQL semantic type, including user and dialect extensions. */
+type AnySqlType = SqlSemanticType<string>;
+type IsUnresolvedSqlType<T> = T extends SqlUnknown ? true : T extends AnySqlType ? string extends T['sqlType'] ? true : false : false;
+/** Whether a declared SQL domain satisfies a semantic capability constraint. */
+type SqlTypeSatisfies<TActual, TConstraint> = true extends IsUnresolvedSqlType<TActual> ? true : TActual extends TConstraint ? true : false;
+type EqualityGroup<T> = T extends SqlEqualityComparable<infer TGroup> ? TGroup : never;
+/** Portable equality compatibility, with unknown extension types left open. */
+type SqlEqualityCompatible<TLeft, TRight> = true extends IsUnresolvedSqlType<TLeft> ? true : true extends IsUnresolvedSqlType<TRight> ? true : [EqualityGroup<TLeft>] extends [never] ? false : [EqualityGroup<TRight>] extends [never] ? false : [EqualityGroup<TLeft>] extends [EqualityGroup<TRight>] ? [EqualityGroup<TRight>] extends [EqualityGroup<TLeft>] ? true : false : false;
+type OrderGroup<T> = T extends SqlOrderable<infer TGroup> ? TGroup : never;
+/** Portable ordering compatibility, with unknown extension types left open. */
+type SqlOrderCompatible<TLeft, TRight> = true extends IsUnresolvedSqlType<TLeft> ? true : true extends IsUnresolvedSqlType<TRight> ? true : [OrderGroup<TLeft>] extends [never] ? false : [OrderGroup<TRight>] extends [never] ? false : [OrderGroup<TLeft>] extends [OrderGroup<TRight>] ? [OrderGroup<TRight>] extends [OrderGroup<TLeft>] ? true : false : false;
+//#endregion
+//#region src/core/fragment.d.ts
+declare const fragmentMetadata: unique symbol;
+/** Result value metadata, including nullability provenance and its SQL domain. */
+type ResultMeta<TOutput, TNullableFrom = never, TSqlType extends AnySqlType = SqlUnknown> = {
+  readonly kind: 'result';
+  readonly output: TOutput;
+  readonly nullableFrom: TNullableFrom;
+  readonly sqlType: TSqlType;
+};
+type RequiresSourceMeta<TSource> = {
+  readonly kind: 'requires-source';
+  readonly source: TSource;
+};
+/** A source that must be provided by the enclosing query scope. */
+type RequiresOuterSourceMeta<TSource> = {
+  readonly kind: 'requires-outer-source';
+  readonly source: TSource;
+};
+/** A correlated query clause that provisions sources from its enclosing scope. */
+type ProvidesOuterSourceMeta<TSource> = {
+  readonly kind: 'provides-outer-source';
+  readonly source: TSource;
+};
+type NullableSourceMeta<TSource> = {
+  readonly kind: 'nullable-source';
+  readonly source: TSource;
+};
+/** A fragment that introduces a typed relational source to FROM/JOIN. */
+type ProvidesSourceMeta<TSource, TRow = unknown> = {
+  readonly kind: 'provides-source';
+  readonly source: TSource;
+  readonly row: TRow;
+};
+/** Dependencies read by an expression at the current query level. */
+type ExpressionMeta<TDependencies = unknown> = {
+  readonly kind: 'expression';
+  readonly dependencies: TDependencies;
+};
+/** Dependencies consumed inside an aggregate expression. */
+type AggregateMeta<TDependencies = unknown> = {
+  readonly kind: 'aggregate';
+  readonly dependencies: TDependencies;
+};
+/** Marks an expression that contains a window function. */
+type WindowMeta = {
+  readonly kind: 'window';
+};
+/** Marks an expression that contains a scalar or predicate subquery. */
+type SubqueryMeta = {
+  readonly kind: 'subquery';
+};
+/** Grouping keys and column dependencies made available by a GROUP BY clause. */
+type GroupingMeta<TKeys = unknown, TDependencies = unknown> = {
+  readonly kind: 'grouping';
+  readonly keys: TKeys;
+  readonly dependencies: TDependencies;
+};
+type QueryCardinality = 'many' | 'zero-or-one' | 'exactly-one';
+type CardinalityMeta<TCardinality extends QueryCardinality = QueryCardinality> = {
+  readonly kind: 'cardinality';
+  readonly cardinality: TCardinality;
+};
+/** A fragment whose syntax must be rendered by a dialect with this capability. */
+type RequiresCapabilityMeta<TCapability extends DialectCapability = DialectCapability> = {
+  readonly kind: 'requires-capability';
+  readonly capability: TCapability;
+};
+type FragmentMeta = ResultMeta<unknown, unknown, AnySqlType> | RequiresSourceMeta<unknown> | RequiresOuterSourceMeta<unknown> | ProvidesOuterSourceMeta<unknown> | NullableSourceMeta<unknown> | ProvidesSourceMeta<unknown, unknown> | ExpressionMeta | AggregateMeta | WindowMeta | SubqueryMeta | GroupingMeta | CardinalityMeta | RequiresCapabilityMeta;
+interface RenderContext {
+  readonly dialect: Dialect;
+  /** Whether selected fields name an application result or a SQL relation. */
+  readonly projectionMode: 'result' | 'relation';
+  append(text: string): void;
+  parameter(value: unknown): void;
+  render(part: Fragment<any>): void;
+  /** Render an embedded query with SQL-facing projection names. */
+  renderRelation(part: Fragment<any>): void;
+  /**
+   * Optional schema-rendering hook used to emit a bare physical column name.
+   * Ordinary query rendering leaves this undefined and retains qualification.
+   */
+  readonly renderColumnReference?: (columnName: string) => void;
+}
+type RenderFunction = (context: RenderContext) => void;
+/**
+ * The smallest composable unit in qubu. Runtime rendering is deliberately
+ * just a function; the metadata type carries semantic information for
+ * TypeScript consumers without imposing an AST on extensions.
+ */
+interface Fragment<TMetadata = any> {
+  readonly [fragmentMetadata]?: TMetadata;
+  readonly render: RenderFunction;
+}
+type AnyFragment = Fragment<any>;
+type MetadataOf<T> = T extends Fragment<infer TMetadata> ? TMetadata : never;
+type WithoutResult<TMetadata> = TMetadata extends {
+  readonly kind: 'result' | 'cardinality';
+} ? never : TMetadata;
+type ResultMetadata<TMetadata> = TMetadata extends {
+  readonly kind: 'result';
+} ? TMetadata : never;
+type ResultOutput<TMetadata> = TMetadata extends {
+  readonly output: infer TOutput;
+} ? TOutput : never;
+type ResultNullableFrom<TMetadata> = TMetadata extends {
+  readonly nullableFrom: infer TSource;
+} ? TSource : never;
+type ResultSqlType<TMetadata> = TMetadata extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown;
+type RequiredSource<TMetadata> = TMetadata extends {
+  readonly kind: 'requires-source';
+  readonly source: infer TSource;
+} ? TSource : never;
+type RequiredOuterSource<TMetadata> = TMetadata extends {
+  readonly kind: 'requires-outer-source';
+  readonly source: infer TSource;
+} ? TSource : never;
+type ProvidedOuterSource<TMetadata> = TMetadata extends {
+  readonly kind: 'provides-outer-source';
+  readonly source: infer TSource;
+} ? TSource : never;
+type NullableSource<TMetadata> = TMetadata extends {
+  readonly kind: 'nullable-source';
+  readonly source: infer TSource;
+} ? TSource : never;
+type ExpressionDependencies<TMetadata> = TMetadata extends {
+  readonly kind: 'expression';
+  readonly dependencies: infer TDependencies;
+} ? TDependencies : never;
+type AggregateDependencies<TMetadata> = TMetadata extends {
+  readonly kind: 'aggregate';
+  readonly dependencies: infer TDependencies;
+} ? TDependencies : never;
+type GroupingKeys<TMetadata> = TMetadata extends {
+  readonly kind: 'grouping';
+  readonly keys: infer TKeys;
+} ? TKeys : never;
+type GroupingDependencies<TMetadata> = TMetadata extends {
+  readonly kind: 'grouping';
+  readonly dependencies: infer TDependencies;
+} ? TDependencies : never;
+type Cardinality<TMetadata> = TMetadata extends {
+  readonly kind: 'cardinality';
+  readonly cardinality: infer TCardinality;
+} ? TCardinality : never;
+type RequiredCapabilities<TMetadata> = TMetadata extends {
+  readonly kind: 'requires-capability';
+  readonly capability: infer TCapability extends DialectCapability;
+} ? TCapability : never;
+type InheritedMetadataOf<TMetadata> = WithoutResult<TMetadata>;
+type InheritedMetadata<T> = InheritedMetadataOf<MetadataOf<T>>;
+type OutputOf<T> = ResultOutput<ResultMetadata<MetadataOf<T>>>;
+/** The SQL semantic domain produced by a result-bearing fragment. */
+type SqlTypeOf<T> = ResultSqlType<ResultMetadata<MetadataOf<T>>>;
+type RequiresOf<T> = RequiredSource<MetadataOf<T>>;
+type RequiresOuterOf<T> = RequiredOuterSource<MetadataOf<T>>;
+type ProvidesOuterOf<T> = ProvidedOuterSource<MetadataOf<T>>;
+type RequiresOuterMetadataOf<T> = Extract<MetadataOf<T>, {
+  readonly kind: 'requires-outer-source';
+}>;
+type NullabilityOf<T> = ResultNullableFrom<ResultMetadata<MetadataOf<T>>>;
+type NullableSourcesOf<T> = NullableSource<MetadataOf<T>>;
+type DependenciesOf<T> = ExpressionDependencies<MetadataOf<T>>;
+type AggregateDependenciesOf<T> = AggregateDependencies<MetadataOf<T>>;
+/** Dependencies still visible after aggregate arguments have been consumed. */
+type VisibleDependenciesOf<T> = Exclude<DependenciesOf<T>, AggregateDependenciesOf<T>>;
+type GroupingKeysOf<T> = GroupingKeys<MetadataOf<T>>;
+type GroupingDependenciesOf<T> = GroupingDependencies<MetadataOf<T>>;
+type HasAggregate<T> = [Extract<MetadataOf<T>, {
+  readonly kind: 'aggregate';
+}>] extends [never] ? false : true;
+type HasWindow<T> = [Extract<MetadataOf<T>, {
+  readonly kind: 'window';
+}>] extends [never] ? false : true;
+type HasSubquery<T> = [Extract<MetadataOf<T>, {
+  readonly kind: 'subquery';
+}>] extends [never] ? false : true;
+type CardinalityOf<T> = Cardinality<MetadataOf<T>>;
+type CapabilitiesOf<T> = RequiredCapabilities<MetadataOf<T>>;
+type CapabilityMetadataOf<T> = [CapabilitiesOf<T>] extends [never] ? never : RequiresCapabilityMeta<CapabilitiesOf<T>>;
+declare function fragment<TMetadata = never>(render: RenderFunction): Fragment<TMetadata>;
+declare function sequence<const TParts extends readonly AnyFragment[]>(parts: TParts, separator?: string): Fragment<InheritedMetadata<TParts[number]>>;
+declare function parenthesize<TPart extends AnyFragment>(part: TPart): Fragment<InheritedMetadata<TPart>>;
+declare function isFragment(value: unknown): value is AnyFragment;
+//#endregion
+//#region src/expressions/types.d.ts
+type ExpressionKind = 'value' | 'column' | 'function' | 'operator' | 'sql' | 'subquery' | 'unsafe';
+/** Runtime/type-level proof that an expression is safe to use in schema SQL. */
+declare const schemaExpressionBrand: unique symbol;
+interface SchemaExpressionBrand {
+  readonly [schemaExpressionBrand]: true;
+}
+interface Expression<TMetadata = any, TKind extends ExpressionKind = ExpressionKind> extends Fragment<TMetadata> {
+  readonly expressionKind: TKind;
+  /** Internal runtime marker for query constructs rejected by schema SQL. */
+  readonly expressionCategory?: 'aggregate' | 'window' | 'subquery';
+}
+/**
+ * An expression whose renderer is deterministic and may be used by schema
+ * metadata. Query extensions remain ordinary {@link Expression} values until
+ * they explicitly opt into this contract.
+ */
+type SchemaExpression<TMetadata = any, TKind extends ExpressionKind = ExpressionKind> = Expression<TMetadata, TKind> & SchemaExpressionBrand;
+type AnyExpression = Expression<any, any>;
+type AnySchemaExpression = SchemaExpression<any, any>;
+type ExpressionOutput<T> = OutputOf<T>;
+type ExpressionRequires<T> = RequiresOf<T>;
+type ExpressionNullability<T> = NullabilityOf<T>;
+/** Extract the SQL semantic domain produced by an expression. */
+type ExpressionSqlType<T> = SqlTypeOf<T>;
+/** Add a concrete dialect requirement without dropping expression metadata. */
+declare function withDialectCapability<const TCapability extends DialectCapability, TExpression extends AnyExpression>(expression: TExpression, capability: TCapability): TExpression extends SchemaExpression<any, any> ? SchemaExpression<MetadataOf<TExpression> | RequiresCapabilityMeta<TCapability>, TExpression['expressionKind']> : Expression<MetadataOf<TExpression> | RequiresCapabilityMeta<TCapability>, TExpression['expressionKind']>;
+/** An expression whose result is known to be assignable to `TOutput`. */
+type ExpressionWithOutput<TOutput, TKind extends ExpressionKind = ExpressionKind> = Expression<ResultMeta<TOutput, unknown, AnySqlType> | RequiresSourceMeta<unknown> | NullableSourceMeta<unknown> | ExpressionMeta<unknown> | AggregateMeta<unknown> | RequiresCapabilityMeta | WindowMeta | SubqueryMeta, TKind>;
+/** Build an expression result while inheriting non-result metadata from children. */
+type ResultExpression<TOutput, TChildren = never, TKind extends ExpressionKind = ExpressionKind, TNullableFrom = NullabilityOf<TChildren>, TSqlType extends AnySqlType = SqlUnknown> = SchemaExpression<ResultMeta<TOutput, TNullableFrom, TSqlType> | ExpressionMeta<DependenciesOf<TChildren>> | InheritedMetadata<TChildren>, TKind>;
+/** Build an aggregate result while recording which dependencies it consumes. */
+type AggregateResultExpression<TOutput, TChildren = never, TKind extends ExpressionKind = ExpressionKind, TNullableFrom = NullabilityOf<TChildren>, TSqlType extends AnySqlType = SqlUnknown> = Expression<ResultMeta<TOutput, TNullableFrom, TSqlType> | ExpressionMeta<DependenciesOf<TChildren>> | AggregateMeta<DependenciesOf<TChildren>> | InheritedMetadata<TChildren>, TKind>;
+/** A result expression that contains a query boundary. */
+type SubqueryResultExpression<TOutput, TChildren = never, TNullableFrom = NullabilityOf<TChildren>, TSqlType extends AnySqlType = SqlUnknown> = Expression<ResultMeta<TOutput, TNullableFrom, TSqlType> | ExpressionMeta<DependenciesOf<TChildren>> | InheritedMetadata<TChildren> | SubqueryMeta, 'subquery'>;
+declare function makeExpression<TMetadata = never, TKind extends ExpressionKind = ExpressionKind>(expressionKind: TKind, render: (context: RenderContext) => void, expressionCategory?: 'aggregate' | 'window' | 'subquery'): Expression<TMetadata, TKind>;
+/** Mark a query-only expression category without changing its SQL renderer. */
+declare function markExpressionCategory<TMetadata, TKind extends ExpressionKind>(expression: Expression<TMetadata, TKind>, category: 'aggregate' | 'window' | 'subquery'): Expression<TMetadata, TKind>;
+declare function isExpression(value: unknown): value is AnyExpression;
+//#endregion
+//#region src/expressions/column.d.ts
+interface ColumnReference<TFieldName extends string = string, TMetadata = never> extends SchemaExpression<TMetadata, 'column'> {
+  /** Application-facing key used by typed rows and dependency metadata. */
+  readonly fieldName: TFieldName;
+  /** Physical SQL identifier rendered for this column. */
+  readonly columnName: string;
+}
+type ColumnDependency<TSource, TName extends string> = {
+  readonly kind: 'column';
+  readonly source: TSource;
+  readonly name: TName;
+};
+type ColumnGroupingDependencies<T> = T extends ColumnReference<any, any> ? DependenciesOf<T> : never;
+/** Turn an expression into a fragment that renders it without changing it. */
+declare function expressionFragment<TExpression extends Expression>(expression: TExpression): Fragment<MetadataOf<TExpression>>;
+//#endregion
+//#region src/schema/metadata.d.ts
+/** Dialect identities with first-party schema metadata adapters. */
+type SchemaDialectName = 'postgresql' | 'sqlite' | 'mysql';
+/** A dialect-owned extension attached to serializable schema metadata. */
+interface SchemaDialectExtension<TDialect extends string = string> {
+  readonly dialect: TDialect;
+}
+/** An optional physical-name override for a relational schema object. */
+interface SchemaObjectNameOptions {
+  /** Physical SQL name; the metadata record key remains the logical ID. */
+  readonly physicalName?: string;
+}
+/** Common identity fields materialized on constraints and indexes. */
+interface SchemaObjectIdentity {
+  /** Stable logical ID, normally the metadata record key. */
+  readonly id?: string;
+  /** Resolved physical SQL object name. */
+  readonly physicalName?: string;
+}
+/** Structured diagnostics produced while resolving relational metadata. */
+interface SchemaMetadataDiagnostic {
+  readonly code: 'invalid-physical-name' | 'duplicate-physical-name' | 'dialect-mismatch' | 'unsupported-dialect-option';
+  readonly message: string;
+  readonly path: readonly (string | number)[];
+  readonly relatedPaths?: readonly (readonly (string | number)[])[];
+  readonly dialect?: string;
+}
+/** Error raised when relational metadata cannot be represented safely. */
+declare class SchemaMetadataValidationError extends TypeError {
+  readonly name = "SchemaMetadataValidationError";
+  readonly diagnostics: readonly SchemaMetadataDiagnostic[];
+  readonly issues: readonly SchemaMetadataDiagnostic[];
+  constructor(diagnostics: readonly SchemaMetadataDiagnostic[]);
+}
+/** Generate the version-one physical name for a relational object ID. */
+declare function generatedSchemaObjectName(id: string): string;
+/** Deep-freeze plain metadata values without introducing executable nodes. */
+declare function freezeSchemaMetadata<T>(value: T): T;
+/** Check the portable identifier subset used for generated metadata names. */
+declare function isValidSchemaObjectName(name: string): boolean;
+/**
+ * Attach a record key and resolved physical name without changing the
+ * enumerable shape of legacy constraint/index values. The properties are
+ * still ordinary read-only runtime metadata and are available to snapshot
+ * traversals.
+ */
+declare function materializeSchemaObjectIdentity<TValue extends object>(value: TValue, id: string, physicalName?: string): TValue & SchemaObjectIdentity;
+type NamedMetadataValue = object & {
+  readonly physicalName?: string;
+};
+/**
+ * Resolve and validate names for one metadata record. The caller decides
+ * whether constraint and index names share a database namespace.
+ */
+declare function materializeSchemaObjectRecord<TValue extends NamedMetadataValue>(record: Readonly<Record<string, TValue>>, kind: 'constraint' | 'index'): Readonly<Record<string, TValue & SchemaObjectIdentity>>;
+/** Return a diagnostic when a dialect extension is used by another adapter. */
+declare function dialectMismatchDiagnostic(extension: SchemaDialectExtension, dialect: string, path: readonly (string | number)[]): SchemaMetadataDiagnostic | undefined;
+/** Throw a structured error for one or more dialect capability findings. */
+declare function assertSchemaDialectSupport(diagnostics: readonly SchemaMetadataDiagnostic[]): void;
+//#endregion
+//#region src/schema/column-behavior.d.ts
+/** Values that can be represented without a dialect-specific SQL renderer. */
+type SchemaLiteralValue = null | boolean | string | number | bigint;
+/**
+ * Public input accepted by a column's `default` option.
+ *
+ * Primitive values are always literals. Branded schema expressions are
+ * rendered as SQL expressions, and an external descriptor records a default
+ * whose definition belongs to another schema authority.
+ */
+type ColumnDefaultInput = SchemaLiteralValue | AnySchemaExpression | ExternalDefaultDescriptor;
+/** A canonical, dialect-neutral literal node retained by default metadata. */
+type CanonicalLiteral = {
+  readonly kind: 'null';
+} | {
+  readonly kind: 'boolean';
+  readonly value: boolean;
+} | {
+  readonly kind: 'string';
+  readonly value: string;
+} | {
+  readonly kind: 'number';
+  readonly value: string;
+} | {
+  readonly kind: 'bigint';
+  readonly value: string;
+};
+/** A default represented by a canonical literal node. */
+interface LiteralDefaultDescriptor<TLiteral extends CanonicalLiteral = CanonicalLiteral> {
+  readonly kind: 'literal';
+  readonly value: TLiteral;
+}
+/** A default whose SQL is retained as a deterministic schema expression. */
+interface ExpressionDefaultDescriptor<TExpression extends AnySchemaExpression = AnySchemaExpression> {
+  readonly kind: 'expression';
+  readonly expression: TExpression;
+}
+/** A default supplied by the database or another external schema authority. */
+interface ExternalDefaultDescriptor {
+  readonly kind: 'external';
+}
+/** Complete default metadata carried by a column definition. */
+type ColumnDefault = LiteralDefaultDescriptor | ExpressionDefaultDescriptor | ExternalDefaultDescriptor;
+/** Alias used by snapshot and schema tooling consumers. */
+type DefaultDescriptor = ColumnDefault;
+/** Storage mode for a generated-column expression. */
+type GeneratedColumnMode = 'stored' | 'virtual';
+/** A generated column with an expression that can be rendered later. */
+interface ExpressionGeneratedColumnDescriptor<TExpression extends AnySchemaExpression = AnySchemaExpression> {
+  readonly kind: 'expression';
+  readonly expression: TExpression;
+  readonly mode: GeneratedColumnMode;
+}
+/** A generated-column behavior known to exist but owned externally. */
+interface ExternalGeneratedColumnDescriptor {
+  readonly kind: 'external';
+}
+/** Complete generated-column metadata, separate from identity metadata. */
+type GeneratedColumnDescriptor = ExpressionGeneratedColumnDescriptor | ExternalGeneratedColumnDescriptor;
+/** Alias used by snapshot and schema tooling consumers. */
+type GeneratedDescriptor = GeneratedColumnDescriptor;
+/** Identity generation policy. Identity is not an ordinary SQL expression. */
+type IdentityGeneration = 'always' | 'by-default';
+/** SQLite's opt-in AUTOINCREMENT behavior for an INTEGER rowid alias. */
+interface SqliteIdentityExtension extends SchemaDialectExtension<'sqlite'> {
+  /** Preserve deleted rowids instead of allowing SQLite to reuse them. */
+  readonly autoIncrement?: boolean;
+}
+/** MySQL's column-level AUTO_INCREMENT identity detail. */
+interface MysqlIdentityExtension extends SchemaDialectExtension<'mysql'> {
+  /** Emit MySQL's AUTO_INCREMENT behavior for this identity column. */
+  readonly autoIncrement?: boolean;
+}
+/** Dialect-owned identity details retained independently from generation. */
+type IdentityDialectExtension = SqliteIdentityExtension | MysqlIdentityExtension | (SchemaDialectExtension<string> & Readonly<Record<string, unknown>>);
+/** Complete identity metadata for a database-generated column value. */
+interface IdentityDescriptor {
+  readonly kind: 'identity';
+  readonly generation: IdentityGeneration;
+  /** Optional dialect-owned identity semantics such as SQLite AUTOINCREMENT. */
+  readonly dialect?: IdentityDialectExtension;
+}
+/** Structured failures raised while resolving column behavior metadata. */
+type ColumnBehaviorErrorCode = 'invalid-default' | 'invalid-generated-column' | 'invalid-identity' | 'invalid-on-update' | 'default-flag-conflict' | 'generated-flag-conflict' | 'default-generated-conflict' | 'identity-generated-conflict';
+/** A column behavior error with a stable code and optional property path. */
+declare class ColumnBehaviorError extends TypeError {
+  readonly code: ColumnBehaviorErrorCode;
+  readonly path?: string;
+  constructor(code: ColumnBehaviorErrorCode, message: string, path?: string);
+}
+/** Build a canonical literal node from a supported JavaScript scalar. */
+declare function canonicalLiteral(value: SchemaLiteralValue): CanonicalLiteral;
+/** Mark a legacy or externally managed database default explicitly. */
+declare function externalDefault(): ExternalDefaultDescriptor;
+/** Create an immutable generated-column descriptor. */
+declare function generatedColumn<const TExpression extends AnySchemaExpression>(expression: TExpression, mode?: GeneratedColumnMode | {
+  readonly mode: GeneratedColumnMode;
+}): ExpressionGeneratedColumnDescriptor<TExpression>;
+/** Mark a legacy or externally managed generated column explicitly. */
+declare function externalGeneratedColumn(): ExternalGeneratedColumnDescriptor;
+/** Describe a database identity column without inventing a generated SQL expression. */
+declare function identityColumn(generation?: IdentityGeneration, options?: {
+  readonly dialect?: IdentityDialectExtension;
+}): IdentityDescriptor;
+/** The normalized behavior fields attached to a column definition. */
+interface ResolvedColumnBehavior {
+  readonly hasDefault: boolean;
+  readonly generated: boolean;
+  readonly default?: ColumnDefault;
+  readonly generatedColumn?: GeneratedColumnDescriptor;
+  readonly identity?: IdentityDescriptor;
+  readonly onUpdate?: AnySchemaExpression;
+}
+/** Normalize complete and legacy column behavior into immutable metadata. */
+declare function resolveColumnBehavior(options: {
+  readonly hasDefault?: boolean;
+  readonly generated?: boolean;
+  readonly default?: ColumnDefaultInput;
+  readonly generatedColumn?: GeneratedColumnDescriptor;
+  readonly identity?: IdentityDescriptor;
+  readonly onUpdate?: AnySchemaExpression;
+}): ResolvedColumnBehavior;
+//#endregion
+//#region src/schema/column.d.ts
+/** Portable physical storage spellings understood by every schema dialect. */
+type PortableStorageType = 'integer' | 'numeric' | 'text' | 'boolean' | 'date' | 'timestamp' | 'uuid' | 'json' | 'bigint' | 'binary';
+/** A dialect-neutral physical storage descriptor. */
+interface PortableColumnStorage<TType extends PortableStorageType = PortableStorageType> {
+  readonly kind: 'portable';
+  /** Stable physical storage category, independent of the SQL domain. */
+  readonly type: TType;
+}
+/** A physical storage declaration owned by one SQL dialect. */
+interface NativeColumnStorage<TDialect extends string = string, TDeclaration extends string = string> {
+  readonly kind: 'native';
+  /** Adapter name that owns the declaration. */
+  readonly dialect: TDialect;
+  /** Exact dialect declaration, preserved without normalization. */
+  readonly type: TDeclaration;
+}
+/** Physical storage metadata carried by a column definition. */
+type ColumnStorage = PortableColumnStorage | NativeColumnStorage;
+/** Alias for callers that prefer the descriptor terminology. */
+type StorageDescriptor = ColumnStorage;
+/** Alias for the complete column storage union. */
+type ColumnStorageDescriptor = ColumnStorage;
+/** Alias for the dialect-owned branch of {@link ColumnStorage}. */
+type DialectNativeStorage<TDialect extends string = string, TDeclaration extends string = string> = NativeColumnStorage<TDialect, TDeclaration>;
+/** Alias for the dialect-owned descriptor terminology. */
+type NativeStorageDescriptor<TDialect extends string = string, TDeclaration extends string = string> = NativeColumnStorage<TDialect, TDeclaration>;
+/** Alias for the portable branch of {@link ColumnStorage}. */
+type PortableStorage<TType extends PortableStorageType = PortableStorageType> = PortableColumnStorage<TType>;
+/** Alias for the portable descriptor terminology. */
+type PortableStorageDescriptor<TType extends PortableStorageType = PortableStorageType> = PortableColumnStorage<TType>;
+/** Alias for the native branch of {@link ColumnStorage}. */
+type NativeStorage<TDialect extends string = string, TDeclaration extends string = string> = NativeColumnStorage<TDialect, TDeclaration>;
+/** Create an immutable portable physical storage descriptor. */
+declare function portableStorage<const TType extends PortableStorageType>(type: TType): PortableColumnStorage<TType>;
+/** Create an immutable dialect-native physical storage descriptor. */
+declare function nativeStorage<const TDialect extends string, const TDeclaration extends string>(dialect: TDialect, type: TDeclaration): NativeColumnStorage<TDialect, TDeclaration>;
+/** Create a native descriptor from a named object for adapter integrations. */
+declare function nativeStorage<const TDialect extends string, const TDeclaration extends string>(options: {
+  readonly dialect: TDialect;
+  readonly type: TDeclaration;
+}): NativeColumnStorage<TDialect, TDeclaration>;
+/** Accept `declaration` when adapting an external type registry. */
+declare function nativeStorage<const TDialect extends string, const TDeclaration extends string>(options: {
+  readonly dialect: TDialect;
+  readonly declaration: TDeclaration;
+}): NativeColumnStorage<TDialect, TDeclaration>;
+/** Describes the storage branch carried by a column definition. */
+type ColumnStorageOf<T> = T extends {
+  readonly storage?: infer TStorage;
+} ? TStorage : never;
+/** Extract the portable storage category from a column definition. */
+type ColumnStorageTypeOf<T> = Extract<ColumnStorageOf<T>, PortableColumnStorage> extends PortableColumnStorage<infer TType> ? TType : never;
+/** Extract the owning dialect from a native column definition. */
+type ColumnStorageDialectOf<T> = Extract<ColumnStorageOf<T>, NativeColumnStorage> extends NativeColumnStorage<infer TDialect, any> ? TDialect : never;
+/** Extract the exact native declaration from a column definition. */
+type ColumnStorageDeclarationOf<T> = Extract<ColumnStorageOf<T>, NativeColumnStorage> extends NativeColumnStorage<any, infer TDeclaration> ? TDeclaration : never;
+/** Extract the descriptor discriminant from a column definition. */
+type ColumnStorageKindOf<T> = Extract<ColumnStorageOf<T>, ColumnStorage>['kind'];
+/** Short alias for {@link ColumnStorageOf}. */
+type StorageOf<T> = ColumnStorageOf<T>;
+/** Alias matching the existing `ColumnSqlType` extraction naming. */
+type ColumnStorageType<T> = ColumnStorageOf<T>;
+/** Alias for the portable category extraction. */
+type StorageTypeOf<T> = ColumnStorageTypeOf<T>;
+/** Alias for the dialect extraction. */
+type StorageDialectOf<T> = ColumnStorageDialectOf<T>;
+/** Alias for the native declaration extraction. */
+type StorageDeclarationOf<T> = ColumnStorageDeclarationOf<T>;
+interface ColumnOptions {
+  readonly nullable?: boolean;
+  readonly hasDefault?: boolean;
+  readonly generated?: boolean;
+  /** A literal, deterministic expression, or externally managed default. */
+  readonly default?: ColumnDefaultInput;
+  /** Complete generated-column metadata, independent of identity behavior. */
+  readonly generatedColumn?: GeneratedColumnDescriptor;
+  /** Database identity metadata; identity is not an ordinary expression. */
+  readonly identity?: IdentityDescriptor;
+  /** MySQL's optional parameter-free `ON UPDATE` expression. */
+  readonly onUpdate?: AnySchemaExpression;
+  /** Override the snake_case SQL identifier derived from the field name. */
+  readonly sqlName?: string;
+  /** Physical storage metadata for a custom column definition. */
+  readonly storage?: ColumnStorage;
+  /**
+   * Raw SQL target that makes a custom definition reusable with cast().
+   * The value is emitted verbatim and must come from trusted source code.
+   */
+  readonly castType?: string;
+}
+type BuiltInColumnOptions = Omit<ColumnOptions, 'castType' | 'storage'> & {
+  readonly castType?: never;
+  readonly storage?: never;
+};
+interface ColumnDefinition<TOutput = unknown, TNullable extends boolean = false, TInsert = TOutput, TUpdate = TInsert, THasDefault extends boolean = false, TGenerated extends boolean = false, TSqlType extends AnySqlType = SqlUnknown, TStorage extends ColumnStorage | undefined = undefined, TDefault extends ColumnDefault | undefined = ColumnDefault | undefined, TGeneratedColumn extends GeneratedColumnDescriptor | undefined = GeneratedColumnDescriptor | undefined, TIdentity extends IdentityDescriptor | undefined = IdentityDescriptor | undefined, TOnUpdate extends AnySchemaExpression | undefined = AnySchemaExpression | undefined> {
+  readonly definitionKind: 'column';
+  readonly nullable: TNullable;
+  readonly hasDefault: THasDefault;
+  readonly generated: TGenerated;
+  /** Complete database default metadata, when known. */
+  readonly default?: TDefault;
+  /** Complete generated-column metadata, when known. */
+  readonly generatedColumn?: TGeneratedColumn;
+  /** Identity behavior is modeled separately from generated expressions. */
+  readonly identity?: TIdentity;
+  /** MySQL's optional parameter-free `ON UPDATE` expression. */
+  readonly onUpdate?: TOnUpdate;
+  readonly sqlName?: string;
+  /** Physical storage metadata, separate from the application and SQL types. */
+  readonly storage?: TStorage;
+  /** Runtime CAST target when this definition can describe a cast result. */
+  readonly castTarget?: CastTarget;
+  readonly __output?: TOutput;
+  readonly __insert?: TInsert;
+  readonly __update?: TUpdate;
+  /**
+   * Narrow the column's application type without changing its runtime
+   * definition.
+   *
+   * @remarks Distinct insert or update types are preserved. This method does
+   * not validate values or add a database constraint.
+   */
+  readonly $type: <const TType extends TOutput>() => ColumnDefinition<TType, TNullable, SameType<TInsert, TOutput> extends true ? TType : TInsert, SameType<TUpdate, TOutput> extends true ? TType : TUpdate, THasDefault, TGenerated, TSqlType, TStorage, TDefault, TGeneratedColumn, TIdentity, TOnUpdate> & (this extends {
+    readonly castTarget: infer TCastTarget extends CastTarget;
+  } ? {
+    readonly castTarget: TCastTarget;
+  } : unknown);
+  readonly __sqlType?: TSqlType;
+}
+type Flag<T extends boolean | undefined> = T extends true ? true : false;
+type HasExplicitOption<TOptions, TKey extends PropertyKey> = TKey extends keyof TOptions ? {} extends Pick<TOptions, TKey> ? false : true : false;
+type ColumnHasDefaultOption<TOptions extends ColumnOptions> = HasExplicitOption<TOptions, 'default'> extends true ? true : Flag<TOptions['hasDefault']>;
+type ColumnIsGeneratedOption<TOptions extends ColumnOptions> = TOptions extends {
+  readonly generatedColumn: GeneratedColumnDescriptor;
+} ? true : TOptions extends {
+  readonly identity: IdentityDescriptor;
+} ? true : Flag<TOptions['generated']>;
+type ColumnDefaultOption<TOptions extends ColumnOptions> = HasExplicitOption<TOptions, 'default'> extends true ? TOptions extends {
+  readonly default: infer TDefault;
+} ? TDefault extends AnySchemaExpression ? ExpressionDefaultDescriptor<TDefault> : TDefault extends ExternalDefaultDescriptor ? TDefault : TDefault extends SchemaLiteralValue ? LiteralDefaultDescriptor : never : never : TOptions['hasDefault'] extends true ? ExternalDefaultDescriptor : undefined;
+type ColumnGeneratedOption<TOptions extends ColumnOptions> = TOptions extends {
+  readonly generatedColumn: infer TGenerated extends GeneratedColumnDescriptor;
+} ? TGenerated : TOptions['generated'] extends true ? ExternalGeneratedColumnDescriptor : undefined;
+type ColumnIdentityOption<TOptions extends ColumnOptions> = TOptions extends {
+  readonly identity: infer TIdentity extends IdentityDescriptor;
+} ? TIdentity : undefined;
+type ColumnOnUpdateOption<TOptions extends ColumnOptions> = TOptions extends {
+  readonly onUpdate: infer TOnUpdate extends AnySchemaExpression;
+} ? TOnUpdate : undefined;
+type IsAny$1<T> = 0 extends 1 & T ? true : false;
+type SameType<TLeft, TRight> = IsAny$1<TLeft> extends true ? IsAny$1<TRight> : IsAny$1<TRight> extends true ? false : [TLeft] extends [TRight] ? [TRight] extends [TLeft] ? true : false : false;
+type ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions extends ColumnOptions, TSqlType extends AnySqlType = SqlUnknown> = ColumnDefinition<TOutput, Flag<TOptions['nullable']>, TInsert, TUpdate, ColumnHasDefaultOption<TOptions>, ColumnIsGeneratedOption<TOptions>, TSqlType, TOptions extends {
+  readonly storage: infer TStorage;
+} ? TStorage extends ColumnStorage ? TStorage : undefined : undefined, ColumnDefaultOption<TOptions>, ColumnGeneratedOption<TOptions>, ColumnIdentityOption<TOptions>, ColumnOnUpdateOption<TOptions>> & (TOptions extends {
+  readonly castType: string;
+} ? {
+  readonly castTarget: NamedCastTarget;
+} : unknown);
+type ColumnOutput<T> = T extends ColumnDefinition<infer TOutput, infer TNullable, any, any, any, any, any, any, any, any> ? TNullable extends true ? TOutput | null : TOutput : never;
+type ColumnInsertInput<T> = T extends ColumnDefinition<any, infer TNullable, infer TInsert, any, any, any, any, any, any, any, any> ? TNullable extends true ? TInsert | null : TInsert : never;
+type ColumnUpdateInput<T> = T extends ColumnDefinition<any, infer TNullable, any, infer TUpdate, any, any, any, any, any, any, any> ? TNullable extends true ? TUpdate | null : TUpdate : never;
+type ColumnHasDefault<T> = T extends ColumnDefinition<any, any, any, any, infer THasDefault, any, any, any, any, any, any> ? THasDefault : false;
+type ColumnIsGenerated<T> = T extends ColumnDefinition<any, any, any, any, any, infer TGenerated, any, any, any, any, any> ? TGenerated : false;
+/** Extract complete default metadata from a column definition. */
+type ColumnDefaultOf<T> = T extends ColumnDefinition<any, any, any, any, any, any, any, any, infer TDefault, any, any> ? TDefault : undefined;
+/** Extract complete generated-column metadata from a column definition. */
+type ColumnGeneratedOf<T> = T extends ColumnDefinition<any, any, any, any, any, any, any, any, any, infer TGenerated, any> ? TGenerated : undefined;
+/** Extract identity metadata from a column definition. */
+type ColumnIdentityOf<T> = T extends ColumnDefinition<any, any, any, any, any, any, any, any, any, any, infer TIdentity> ? TIdentity : undefined;
+/** Extract a column's optional deterministic `ON UPDATE` expression. */
+type ColumnOnUpdateOf<T> = T extends ColumnDefinition<any, any, any, any, any, any, any, any, any, any, any, infer TOnUpdate> ? TOnUpdate : undefined;
+/** Extract the SQL semantic domain declared by a column definition. */
+type ColumnSqlType<T> = T extends ColumnDefinition<any, any, any, any, any, any, infer TSqlType, any, any, any, any> ? TSqlType : SqlUnknown;
+/** Whether a column definition explicitly permits SQL NULL values. */
+type ColumnIsNullable<T> = T extends ColumnDefinition<any, infer TNullable, any, any, any, any, any, any, any, any, any> ? TNullable : false;
+type FalseColumnOptions = {
+  readonly nullable?: false;
+  readonly hasDefault?: false;
+  readonly generated?: false;
+  readonly sqlName?: string;
+};
+type AnyColumnDefinition = ColumnDefinition<any, any, any, any, any, any, AnySqlType, any, any, any, any>;
+type NamedCastColumn<TDefinition extends AnyColumnDefinition> = TDefinition & {
+  readonly castTarget: NamedCastTarget;
+};
+type PortableCastColumn<TDefinition extends AnyColumnDefinition, TType extends PortableCastType> = TDefinition & {
+  readonly castTarget: PortableCastTarget<TType>;
+};
+type StoredColumnDefinition<TDefinition extends AnyColumnDefinition, TStorage extends ColumnStorage> = TDefinition extends ColumnDefinition<infer TOutput, infer TNullable, infer TInsert, infer TUpdate, infer THasDefault, infer TGenerated, infer TSqlType, any, infer TDefault, infer TGeneratedColumn, infer TIdentity, infer TOnUpdate> ? ColumnDefinition<TOutput, TNullable, TInsert, TUpdate, THasDefault, TGenerated, TSqlType, TStorage, TDefault, TGeneratedColumn, TIdentity, Extract<TOnUpdate, AnySchemaExpression> | undefined> & (TDefinition extends {
+  readonly castTarget: infer TCastTarget extends CastTarget;
+} ? {
+  readonly castTarget: TCastTarget;
+} : unknown) : never;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown, const TStorage extends ColumnStorage = ColumnStorage, const TOptions extends Omit<ColumnOptions, 'storage'> = Omit<ColumnOptions, 'storage'>>(options: TOptions & {
+  readonly storage: TStorage;
+}): ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions & {
+  readonly storage: TStorage;
+}, TSqlType>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown>(options: FalseColumnOptions & {
+  readonly castType: string;
+}): NamedCastColumn<ColumnDefinition<TOutput, false, TInsert, TUpdate, false, false, TSqlType>>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown>(options: {
+  readonly nullable: true;
+  readonly hasDefault: true;
+  readonly generated: true;
+  readonly sqlName?: string;
+}): ColumnDefinition<TOutput, true, TInsert, TUpdate, true, true, TSqlType, undefined, ExternalDefaultDescriptor, ExternalGeneratedColumnDescriptor>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown>(options: {
+  readonly nullable: true;
+  readonly hasDefault: true;
+  readonly generated?: false;
+  readonly sqlName?: string;
+}): ColumnDefinition<TOutput, true, TInsert, TUpdate, true, false, TSqlType, undefined, ExternalDefaultDescriptor>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown>(options: {
+  readonly nullable: true;
+  readonly hasDefault?: false;
+  readonly generated: true;
+  readonly sqlName?: string;
+}): ColumnDefinition<TOutput, true, TInsert, TUpdate, false, true, TSqlType, undefined, undefined, ExternalGeneratedColumnDescriptor>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown>(options: {
+  readonly nullable: true;
+  readonly hasDefault?: false;
+  readonly generated?: false;
+  readonly sqlName?: string;
+}): ColumnDefinition<TOutput, true, TInsert, TUpdate, false, false, TSqlType>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown>(options: {
+  readonly nullable?: false;
+  readonly hasDefault: true;
+  readonly generated: true;
+  readonly sqlName?: string;
+}): ColumnDefinition<TOutput, false, TInsert, TUpdate, true, true, TSqlType, undefined, ExternalDefaultDescriptor, ExternalGeneratedColumnDescriptor>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown>(options: {
+  readonly nullable?: false;
+  readonly hasDefault: true;
+  readonly generated?: false;
+  readonly sqlName?: string;
+}): ColumnDefinition<TOutput, false, TInsert, TUpdate, true, false, TSqlType, undefined, ExternalDefaultDescriptor>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown>(options: {
+  readonly nullable?: false;
+  readonly hasDefault?: false;
+  readonly generated: true;
+  readonly sqlName?: string;
+}): ColumnDefinition<TOutput, false, TInsert, TUpdate, false, true, TSqlType, undefined, undefined, ExternalGeneratedColumnDescriptor>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown>(options?: FalseColumnOptions): ColumnDefinition<TOutput, false, TInsert, TUpdate, false, false, TSqlType>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown, const TOptions extends ColumnOptions = {}>(options?: TOptions): ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, const TOptions extends ColumnOptions = {}, TSqlType extends AnySqlType = SqlUnknown>(options?: TOptions): ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType>;
+type NativeColumnOptions = Omit<ColumnOptions, 'storage'> & {
+  readonly storage?: never;
+};
+type NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions extends NativeColumnOptions, TSqlType extends AnySqlType, TDialect extends string, TDeclaration extends string> = ColumnDefinition<TOutput, Flag<TOptions['nullable']>, TInsert, TUpdate, ColumnHasDefaultOption<TOptions>, ColumnIsGeneratedOption<TOptions>, TSqlType, NativeColumnStorage<TDialect, TDeclaration>, ColumnDefaultOption<TOptions>, ColumnGeneratedOption<TOptions>, ColumnIdentityOption<TOptions>, ColumnOnUpdateOption<TOptions>> & (TOptions extends {
+  readonly castType: string;
+} ? {
+  readonly castTarget: NamedCastTarget;
+} : unknown);
+/** Create a column whose physical declaration belongs to one SQL dialect. */
+declare function nativeColumn<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, const TOptions extends NativeColumnOptions = {}, TSqlType extends AnySqlType = SqlUnknown, const TDialect extends string = string, const TDeclaration extends string = string>(storage: NativeColumnStorage<TDialect, TDeclaration>, options?: TOptions): NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType, TDialect, TDeclaration>;
+/** Create a dialect-native column from an adapter name and exact declaration. */
+declare function nativeColumn<const TDialect extends string, const TDeclaration extends string, TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, const TOptions extends NativeColumnOptions = {}, TSqlType extends AnySqlType = SqlUnknown>(dialect: TDialect, type: TDeclaration, options?: TOptions): NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType, TDialect, TDeclaration>;
+declare function nullable<TOutput, TNullable extends boolean, TInsert, TUpdate, THasDefault extends boolean, TGenerated extends boolean, TSqlType extends AnySqlType, TStorage extends ColumnStorage | undefined, TDefault extends ColumnDefault | undefined, TGeneratedColumn extends GeneratedColumnDescriptor | undefined, TIdentity extends IdentityDescriptor | undefined, TOnUpdate extends AnySchemaExpression | undefined>(definition: ColumnDefinition<TOutput, TNullable, TInsert, TUpdate, THasDefault, TGenerated, TSqlType, TStorage, TDefault, TGeneratedColumn, TIdentity, TOnUpdate>): ColumnDefinition<TOutput, true, TInsert, TUpdate, THasDefault, TGenerated, TSqlType, TStorage, TDefault, TGeneratedColumn, TIdentity, TOnUpdate>;
+declare function integer<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): StoredColumnDefinition<PortableCastColumn<ColumnFromOptions<number, number, number, TOptions, SqlInteger>, "integer">, PortableColumnStorage<"integer">>;
+declare function numeric<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): StoredColumnDefinition<PortableCastColumn<ColumnFromOptions<number, number, number, TOptions, SqlDecimal>, "decimal">, PortableColumnStorage<"numeric">>;
+declare function text<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): StoredColumnDefinition<PortableCastColumn<ColumnFromOptions<string, string, string, TOptions, SqlText>, "text">, PortableColumnStorage<"text">>;
+declare function boolean<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): StoredColumnDefinition<PortableCastColumn<ColumnFromOptions<boolean, boolean, boolean, TOptions, SqlBoolean>, "boolean">, PortableColumnStorage<"boolean">>;
+declare function date<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): StoredColumnDefinition<PortableCastColumn<ColumnFromOptions<Date, Date, Date, TOptions, SqlDate>, "date">, PortableColumnStorage<"date">>;
+declare function timestamp<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): StoredColumnDefinition<PortableCastColumn<ColumnFromOptions<Date, Date, Date, TOptions, SqlTimestamp>, "timestamp">, PortableColumnStorage<"timestamp">>;
+declare function uuid<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): StoredColumnDefinition<PortableCastColumn<ColumnFromOptions<string, string, string, TOptions, SqlUuid>, "uuid">, PortableColumnStorage<"uuid">>;
+declare function json<TOutput = unknown, const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): StoredColumnDefinition<PortableCastColumn<ColumnFromOptions<TOutput, TOutput, TOutput, TOptions, SqlJson<TOutput>>, "json">, PortableColumnStorage<"json">>;
+declare function bigint<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): StoredColumnDefinition<PortableCastColumn<ColumnFromOptions<bigint, bigint, bigint, TOptions, SqlBigInt>, "bigint">, PortableColumnStorage<"bigint">>;
+declare function binary<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): StoredColumnDefinition<PortableCastColumn<ColumnFromOptions<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, TOptions, SqlBinary>, "binary">, PortableColumnStorage<"binary">>;
+//#endregion
+//#region src/schema/column-nullability.d.ts
+declare const declaredColumnNullability: unique symbol;
+/** @internal */
+type DeclaredColumnNullability<TNullable extends boolean> = {
+  readonly [declaredColumnNullability]: TNullable;
+};
+/** @internal */
+type DeclaredColumnNullabilityOf<TColumn> = TColumn extends DeclaredColumnNullability<infer TNullable> ? TNullable : never;
+//#endregion
+//#region src/schema/constraints.d.ts
+declare const fieldConstraint: unique symbol;
+/** Application and SQL facts that a reusable source field may require. */
+interface FieldLikeOptions {
+  readonly output?: unknown;
+  readonly sqlType?: object;
+  readonly nullable?: boolean;
+}
+/**
+ * A reusable source-field requirement combining application and SQL facts.
+ * Omitted facts impose no constraint; `nullable: false` requires a non-null
+ * selected value.
+ */
+interface FieldLike<TOptions extends FieldLikeOptions = FieldLikeOptions> {
+  readonly [fieldConstraint]: TOptions;
+}
+type FieldOptions<T> = T extends FieldLike<infer TOptions> ? TOptions : never;
+type RequiredOutput<T> = T extends FieldLike<any> ? FieldOptions<T> extends {
+  readonly output: infer TOutput;
+} ? FieldOptions<T> extends {
+  readonly nullable: false;
+} ? NonNullable<TOutput> : TOutput : FieldOptions<T> extends {
+  readonly nullable: false;
+} ? {} : unknown : T;
+type RequiredSqlType<T> = T extends FieldLike<any> ? FieldOptions<T> extends {
+  readonly sqlType: infer TSqlType;
+} ? (AnySqlType & TSqlType) | SqlUnknown : AnySqlType : AnySqlType;
+type RequiredColumn<TField extends string, TRequirement, TIdentity> = ColumnReference<TField, ResultMeta<RequiredOutput<TRequirement>, TIdentity, RequiredSqlType<TRequirement>> | RequiresSourceMeta<TIdentity> | ExpressionMeta<ColumnDependency<TIdentity, TField>>>;
+type RequiredColumns<TShape extends object, TIdentity> = { readonly [K in keyof TShape]-?: K extends string ? RequiredColumn<K, TShape[K], TIdentity> : never; };
+/**
+ * A source containing at least the requested application and SQL fields.
+ * Additional fields and the concrete source identity are preserved by generic
+ * functions that accept this lower-bound constraint.
+ */
+interface SourceLike<TShape extends object> extends Fragment<any> {
+  readonly sourceKind: SourceKind;
+  readonly [sourceIdentity]: unknown;
+  readonly reference: Fragment<never>;
+  readonly columns: RequiredColumns<TShape, this[typeof sourceIdentity]>;
+}
+/** The physical-table form of the lower-bound {@link SourceLike} constraint. */
+interface TableLike<TShape extends object> extends SourceLike<TShape> {
+  readonly tableName: string;
+  readonly definitions: object;
+  readonly sqlNames: Readonly<Record<string, string>>;
+}
+/** Standard SQL referential action retained on a foreign-key constraint. */
+type ReferentialAction = 'no-action' | 'restrict' | 'cascade' | 'set-null' | 'set-default';
+/** Standard SQL match mode for a composite foreign key. */
+type ForeignKeyMatch = 'simple' | 'full' | 'partial';
+/** Deferrability timing for a foreign-key or key constraint. */
+type ConstraintTiming = 'immediate' | 'deferred';
+/** PostgreSQL-only constraint options retained for a schema adapter. */
+interface PostgresConstraintExtension extends SchemaDialectExtension<'postgresql'> {
+  /** PostgreSQL `NOT VALID` validation state for a constraint. */
+  readonly notValid?: boolean;
+}
+/** SQLite-only table-constraint options. */
+interface SqliteConstraintExtension extends SchemaDialectExtension<'sqlite'> {
+  /** SQLite conflict policy attached to a table constraint. */
+  readonly onConflict?: 'rollback' | 'abort' | 'fail' | 'ignore' | 'replace';
+}
+/** MySQL-only constraint options. */
+interface MysqlConstraintExtension extends SchemaDialectExtension<'mysql'> {
+  /** MySQL 8 constraint enforcement state. */
+  readonly enforced?: boolean;
+}
+/** First-party and user-defined dialect extensions for constraints. */
+type ConstraintDialectExtension = PostgresConstraintExtension | SqliteConstraintExtension | MysqlConstraintExtension | (SchemaDialectExtension<string> & Readonly<Record<string, unknown>>);
+/** Shared physical-name and dialect-extension options for constraints. */
+interface ConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends SchemaObjectNameOptions {
+  /** Engine-specific metadata owned by a future schema adapter. */
+  readonly dialect?: TExtension;
+}
+/** Options for primary-key and candidate-key declarations. */
+interface KeyConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
+  /** Whether the key can be deferred by a supporting dialect. */
+  readonly deferrable?: boolean;
+  /** Initial enforcement timing for a deferrable key. */
+  readonly initially?: ConstraintTiming;
+}
+/** Options for a database unique constraint, including nullable columns. */
+interface UniqueConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
+  /**
+   * SQL NULL comparison semantics. `distinct` is the common default in which
+   * multiple NULL values do not conflict; `not-distinct` permits at most one.
+   */
+  readonly nulls?: UniqueNullSemantics;
+  /** Whether the constraint can be deferred by a supporting dialect. */
+  readonly deferrable?: boolean;
+  /** Initial enforcement timing for a deferrable constraint. */
+  readonly initially?: ConstraintTiming;
+}
+/** Explicit NULL behavior for a database uniqueness rule. */
+type UniqueNullSemantics = 'distinct' | 'not-distinct';
+/** Options for a table check constraint. */
+interface CheckConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
+  /** Whether the check can be deferred by a supporting dialect. */
+  readonly deferrable?: boolean;
+  /** Initial enforcement timing for a deferrable check. */
+  readonly initially?: ConstraintTiming;
+}
+/** Dialect tag and parameter-free SQL needed to reconstruct a catalog check. */
+interface CatalogCheckSql<TDialect extends SchemaDialectName = SchemaDialectName> {
+  /** Catalog dialect that supplied the check expression. */
+  readonly dialect: TDialect;
+  /** Opaque SQL text recovered from the catalog. */
+  readonly sql: string;
+}
+/** Options for a foreign-key declaration. */
+interface ForeignKeyOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
+  readonly onUpdate?: ReferentialAction;
+  readonly onDelete?: ReferentialAction;
+  readonly match?: ForeignKeyMatch;
+  readonly deferrable?: boolean;
+  readonly initially?: ConstraintTiming;
+}
+/** A schema constraint whose columns form a relational key. */
+interface KeyConstraint<TKind extends 'primary-key' | 'unique' = 'primary-key' | 'unique', TColumns extends readonly ColumnReference<string, any>[] = readonly ColumnReference<string, any>[]> extends SchemaObjectIdentity {
+  readonly kind: TKind;
+  readonly columns: TColumns;
+  readonly physicalName?: string;
+  readonly dialect?: ConstraintDialectExtension;
+  readonly deferrable?: boolean;
+  readonly initially?: ConstraintTiming;
+}
+/** A referenced table and exact candidate-key column tuple. */
+interface ForeignKeyTarget<TTable extends TableLike<any> = TableLike<any>, TColumns extends readonly AnyKeyColumn[] = readonly AnyKeyColumn[]> {
+  readonly table: TTable;
+  readonly columns: TColumns;
+}
+type ForeignKeyTargetInput<TTarget extends ForeignKeyTarget = ForeignKeyTarget> = TTarget | (() => TTarget);
+/** A foreign key from local columns to a direct or lazily resolved target. */
+interface ForeignKeyConstraint<TColumns extends readonly AnyKeyColumn[] = readonly AnyKeyColumn[], TTarget extends ForeignKeyTargetInput = ForeignKeyTargetInput> extends SchemaObjectIdentity {
+  readonly kind: 'foreign-key';
+  readonly columns: TColumns;
+  readonly target: TTarget;
+  readonly physicalName?: string;
+  readonly dialect?: ConstraintDialectExtension;
+  readonly onUpdate?: ReferentialAction;
+  readonly onDelete?: ReferentialAction;
+  readonly match?: ForeignKeyMatch;
+  readonly deferrable?: boolean;
+  readonly initially?: ConstraintTiming;
+}
+/** Database uniqueness that deliberately does not prove a candidate key. */
+interface UniqueConstraint<TColumns extends readonly AnyKeyColumn[] = readonly AnyKeyColumn[], TNulls extends UniqueNullSemantics = UniqueNullSemantics> extends SchemaObjectIdentity {
+  readonly kind: 'unique-constraint';
+  readonly columns: TColumns;
+  readonly nulls: TNulls;
+  readonly physicalName?: string;
+  readonly dialect?: ConstraintDialectExtension;
+  readonly deferrable?: boolean;
+  readonly initially?: ConstraintTiming;
+}
+/** A table-scoped boolean invariant. */
+interface CheckConstraint<TExpression extends AnyExpression = AnyExpression> extends SchemaObjectIdentity {
+  readonly kind: 'check';
+  readonly expression: TExpression;
+  readonly physicalName?: string;
+  readonly dialect?: ConstraintDialectExtension;
+  readonly deferrable?: boolean;
+  readonly initially?: ConstraintTiming;
+}
+/**
+ * Opaque catalog SQL whose check-constraint origin proves a boolean SQL
+ * semantic type. The expression remains dialect-tagged and parameter-free.
+ */
+interface CatalogCheckExpression<TDialect extends SchemaDialectName = SchemaDialectName> extends SchemaExpression<ResultMeta<boolean, never, SqlBoolean> | ExpressionMeta<never>, 'unsafe'> {
+  readonly schemaSqlDialect: TDialect;
+  readonly schemaSql: string;
+}
+/** Structured schema metadata carried by sources that declare constraints. */
+type SourceConstraint = KeyConstraint | UniqueConstraint | ForeignKeyConstraint | CheckConstraint;
+/** Named schema constraints attached to a source. */
+type SourceConstraintsRecord = Readonly<Record<string, SourceConstraint>>;
+/**
+ * Validate one constraint against a schema adapter dialect. This is kept
+ * separate from construction because the same declaration can be inspected
+ * for more than one target dialect before a serializer is selected.
+ */
+declare function validateConstraintDialect(constraint: SourceConstraint, dialect: string, path?: readonly (string | number)[]): readonly SchemaMetadataDiagnostic[];
+type AnyKeyColumn = ColumnReference<string, any>;
+type ColumnSource<TColumn> = DependenciesOf<TColumn> extends ColumnDependency<infer TSource, string> ? TSource : never;
+type IsNullableKeyColumn<TColumn> = [DeclaredColumnNullabilityOf<TColumn>] extends [never] ? null extends OutputOf<TColumn> ? true : false : true extends DeclaredColumnNullabilityOf<TColumn> ? true : false;
+type InvalidKeyColumn<TColumn, TSource> = TColumn extends AnyKeyColumn ? IsNullableKeyColumn<TColumn> extends true ? TColumn : DependenciesOf<TColumn> extends ColumnDependency<TSource, string> ? never : TColumn : TColumn;
+type KeyColumnsValidation<TColumns extends readonly AnyKeyColumn[]> = [{ [K in keyof TColumns]: InvalidKeyColumn<TColumns[K], ColumnSource<TColumns[0]>>; }[number]] extends [never] ? unknown : never;
+type SameSourceColumnsValidation<TColumns extends readonly AnyKeyColumn[]> = [{ [K in keyof TColumns]: TColumns[K] extends AnyKeyColumn ? DependenciesOf<TColumns[K]> extends ColumnDependency<ColumnSource<TColumns[0]>, string> ? never : TColumns[K] : TColumns[K]; }[number]] extends [never] ? unknown : never;
+type SameSqlDomain<TLeft, TRight> = SqlTypeOf<TLeft> extends (infer TLeftSql) ? SqlTypeOf<TRight> extends (infer TRightSql) ? TLeftSql extends SqlUnknown ? false : TRightSql extends SqlUnknown ? false : TLeftSql extends AnySqlType ? TRightSql extends AnySqlType ? string extends TLeftSql['sqlType'] ? false : string extends TRightSql['sqlType'] ? false : [TLeftSql['sqlType']] extends [TRightSql['sqlType']] ? [TRightSql['sqlType']] extends [TLeftSql['sqlType']] ? true : false : false : false : false : false : false;
+type ForeignKeyColumnsValidation<TLocal extends readonly AnyKeyColumn[], TTarget extends readonly AnyKeyColumn[]> = TLocal extends readonly [infer TLocalHead, ...infer TLocalTail] ? TTarget extends readonly [infer TTargetHead, ...infer TTargetTail] ? TLocalHead extends AnyKeyColumn ? TTargetHead extends AnyKeyColumn ? SameSqlDomain<TLocalHead, TTargetHead> extends true ? ForeignKeyColumnsValidation<Extract<TLocalTail, readonly AnyKeyColumn[]>, Extract<TTargetTail, readonly AnyKeyColumn[]>> : never : never : never : never : TTarget extends readonly [] ? unknown : never;
+type IsUnresolvedSqlDomain<TSqlType> = TSqlType extends SqlUnknown ? true : TSqlType extends AnySqlType ? string extends TSqlType['sqlType'] ? true : false : true;
+type CatalogSqlDomainCompatible<TLeft, TRight> = true extends IsUnresolvedSqlDomain<SqlTypeOf<TLeft>> | IsUnresolvedSqlDomain<SqlTypeOf<TRight>> ? true : SameSqlDomain<TLeft, TRight>;
+type CatalogForeignKeyColumnsValidation<TLocal extends readonly AnyKeyColumn[], TTarget extends readonly AnyKeyColumn[]> = TLocal extends readonly [infer TLocalHead, ...infer TLocalTail] ? TTarget extends readonly [infer TTargetHead, ...infer TTargetTail] ? TLocalHead extends AnyKeyColumn ? TTargetHead extends AnyKeyColumn ? CatalogSqlDomainCompatible<TLocalHead, TTargetHead> extends true ? CatalogForeignKeyColumnsValidation<Extract<TLocalTail, readonly AnyKeyColumn[]>, Extract<TTargetTail, readonly AnyKeyColumn[]>> : never : never : never : never : TTarget extends readonly [] ? unknown : never;
+type CheckExpressionValidation<TExpression> = [SqlTypeOf<TExpression>] extends [never] ? never : SqlTypeOf<TExpression> extends SqlBoolean ? unknown : never;
+/** Declare a primary key, including a composite primary key. */
+declare function primaryKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(...columns: TColumns & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<'primary-key', TColumns>;
+declare function primaryKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TOptions extends KeyConstraintOptions>(...columnsAndOptions: [...TColumns, TOptions] & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<'primary-key', TColumns>;
+/** Declare a non-null unique key, including a composite unique key. */
+declare function unique<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(...columns: TColumns & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<'unique', TColumns>;
+declare function unique<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TOptions extends KeyConstraintOptions>(...columnsAndOptions: [...TColumns, TOptions] & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<'unique', TColumns>;
+/**
+ * Describe database uniqueness without claiming that the columns determine a
+ * row. Nullable columns are accepted, and the NULL behavior is explicit in
+ * the returned metadata. Use {@link unique} when a type-level key proof is
+ * intended.
+ */
+declare function uniqueConstraint<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(...columns: TColumns & SameSourceColumnsValidation<NoInfer<TColumns>>): UniqueConstraint<TColumns, 'distinct'>;
+declare function uniqueConstraint<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TOptions extends UniqueConstraintOptions>(...columnsAndOptions: [...TColumns, TOptions] & SameSourceColumnsValidation<NoInfer<TColumns>>): UniqueConstraint<TColumns, TOptions extends {
+  readonly nulls: infer TNulls extends UniqueNullSemantics;
+} ? TNulls : 'distinct'>;
+/** Pair a table with the exact columns targeted by a foreign key. */
+declare function references<TTable extends TableLike<any>, const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(table: TTable, ...columns: TColumns): ForeignKeyTarget<TTable, TColumns>;
+type ResolvedTarget$1<T> = T extends (() => infer TResolved) ? TResolved : T;
+/** Declare a single-column or composite foreign key. */
+declare function foreignKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TTarget extends ForeignKeyTargetInput, const TOptions extends ForeignKeyOptions = {}>(columns: TColumns & SameSourceColumnsValidation<NoInfer<TColumns>>, target: TTarget & (ResolvedTarget$1<TTarget> extends ForeignKeyTarget<any, infer TTargetColumns> ? ForeignKeyColumnsValidation<TColumns, TTargetColumns> : never), options?: TOptions): ForeignKeyConstraint<TColumns, TTarget>;
+/**
+ * Reconstruct a foreign key proved by database catalog metadata.
+ *
+ * @remarks
+ * Use this helper for generated or introspection-owned declarations when one
+ * or both native SQL domains are unresolved. It accepts unresolved domains,
+ * but still rejects known domain mismatches, unequal tuple arity, and local
+ * columns from different sources. The enclosing `table()` declaration
+ * continues to verify target-column ownership and candidate-key metadata.
+ * Resolved targets also receive runtime shape, ownership, and arity checks.
+ * The returned value serializes as an ordinary foreign-key constraint.
+ */
+declare function catalogForeignKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TTarget extends ForeignKeyTargetInput, const TOptions extends ForeignKeyOptions = {}>(columns: TColumns & SameSourceColumnsValidation<NoInfer<TColumns>>, target: TTarget & (ResolvedTarget$1<TTarget> extends ForeignKeyTarget<any, infer TTargetColumns> ? CatalogForeignKeyColumnsValidation<TColumns, TTargetColumns> : never), options?: TOptions): ForeignKeyConstraint<TColumns, TTarget>;
+/** Declare a boolean table invariant. */
+declare function check<const TExpression extends Expression<any, any>, const TOptions extends CheckConstraintOptions = {}>(expression: TExpression & CheckExpressionValidation<TExpression>, options?: TOptions): CheckConstraint<TExpression>;
+/**
+ * Reconstruct a boolean check from opaque SQL recovered from a database
+ * catalog.
+ *
+ * @remarks
+ * This helper records catalog origin as a narrow type-level proof. It
+ * gives the opaque expression the {@link SqlBoolean} semantic type without
+ * changing the ordinary {@link check} contract. Qubu does not parse or infer
+ * dependencies from the SQL. It preserves the text apart from normalizing
+ * line endings and retains the dialect tag in serialized schema metadata.
+ */
+declare function catalogCheck<const TDialect extends SchemaDialectName, const TOptions extends CheckConstraintOptions = {}>(input: CatalogCheckSql<TDialect>, options?: TOptions): CheckConstraint<CatalogCheckExpression<TDialect>>;
+//#endregion
+//#region src/query/errors.d.ts
+/** Stable diagnostics shared by type-level and runtime query validation. */
+type QueryValidationErrorCode = 'invalid-selection' | 'duplicate-clause' | 'invalid-mutation' | 'unsafe-mutation' | 'invalid-update' | 'invalid-insert' | 'invalid-comparison' | 'invalid-boolean-expression' | 'invalid-pagination' | 'invalid-row-lock' | 'invalid-json-path' | 'missing-source' | 'invalid-grouping' | 'incompatible-sql-domain' | 'incompatible-sql-equality' | 'incompatible-sql-order' | 'incompatible-set-domain' | 'invalid-subquery' | 'invalid-omission' | 'invalid-stream-query' | 'invalid-explain-query' | 'invalid-explain-options' | 'unsupported-explain-option' | 'unsupported-explain-dialect' | 'missing-dialect-capability';
+interface QueryValidationIssue {
+  readonly code: QueryValidationErrorCode;
+  readonly context: string;
+  readonly path: readonly (string | number)[];
+  readonly message: string;
+  readonly hint: string;
+}
+/**
+ * A type-level query failure that names the failing rule and the repair path.
+ * The legacy detail field is optional so each validator can retain the useful
+ * source or clause type in the compiler diagnostic.
+ */
+type QueryTypeValidation<TCode extends QueryValidationErrorCode, TContext extends string, THint extends string, TDetail = never> = {
+  readonly __qubu_error_code__: TCode;
+  readonly __qubu_error_context__: TContext;
+  readonly __qubu_error_hint__: THint;
+} & ([TDetail] extends [never] ? unknown : {
+  readonly __qubu_error_detail__: TDetail;
+});
+/** Raised when a query cannot satisfy Qubu's runtime authoring rules. */
+declare class QueryValidationError extends TypeError {
+  readonly name = "QueryValidationError";
+  readonly code: QueryValidationErrorCode;
+  readonly context: string;
+  readonly path: readonly (string | number)[];
+  readonly hint: string;
+  readonly issue: QueryValidationIssue;
+  constructor(issue: QueryValidationIssue);
+}
+//#endregion
+//#region src/core/render.d.ts
+type DefaultDialectCapability = 'json';
+interface RenderedQuery {
+  readonly text: string;
+  readonly parameters: readonly unknown[];
+}
+interface RenderOptions<TCapabilities extends DialectCapability = DialectCapability> {
+  readonly dialect?: Dialect<TCapabilities>;
+}
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type MissingCapabilities<TQuery, TCapabilities extends DialectCapability> = IsAny<CapabilitiesOf<TQuery>> extends true ? never : Exclude<CapabilitiesOf<TQuery>, TCapabilities>;
+type RenderCapabilityValidation<TQuery, TCapabilities extends DialectCapability> = [MissingCapabilities<TQuery, TCapabilities>] extends [never] ? unknown : QueryTypeValidation<'missing-dialect-capability', 'render.dialect', 'Provide a dialect that supports every capability required by the query.', MissingCapabilities<TQuery, TCapabilities>>;
+declare function render<TQuery extends AnyFragment>(query: TQuery & RenderCapabilityValidation<TQuery, DefaultDialectCapability>): RenderedQuery;
+declare function render<TQuery extends AnyFragment, TCapabilities extends DialectCapability>(query: TQuery & RenderCapabilityValidation<TQuery, TCapabilities>, options: RenderOptions<TCapabilities> | Dialect<TCapabilities>): RenderedQuery;
+//#endregion
+//#region src/execution.d.ts
+type StreamableQuery<TRow extends object = Record<string, unknown>> = Query<TRow, any, any, any> & {
+  readonly queryKind: 'select' | 'set';
+};
+/** Rendering policy and cancellation input accepted by query execution. */
+interface ExecutionOptions extends RenderOptions {
+  /** Passed to the application adapter for drivers that support cancellation. */
+  readonly signal?: AbortSignal;
+}
+/** Rendering, EXPLAIN, and cancellation options for plan requests. */
+interface ExplainOptions extends RenderOptions, ExplainRenderOptions {
+  /** Passed to the application adapter for drivers that support cancellation. */
+  readonly signal?: AbortSignal;
+}
+/** EXPLAIN options accepted for SELECT and set-operation queries. */
+type ExplainReadOptions = ExplainOptions;
+/** EXPLAIN options for mutations, which never run with analysis enabled. */
+type ExplainMutationOptions = Omit<ExplainOptions, 'analyze'> & {
+  readonly analyze?: never;
+};
+/** Select read-only or plan-only EXPLAIN options from the query kind. */
+type ExplainOptionsFor<TQuery extends Query<any, any, any, any>> = TQuery['queryKind'] extends 'select' | 'set' ? ExplainReadOptions : ExplainMutationOptions;
+/** Controls the lifecycle of one adapter-owned transaction. */
+interface TransactionOptions {
+  /** Passed to the adapter for transaction begin, commit, and rollback. */
+  readonly signal?: AbortSignal;
+}
+/** One rendered statement and the controls passed to an application adapter. */
+interface ExecutionRequest {
+  /** SQL text and raw application parameters produced by Qubu's renderer. */
+  readonly statement: RenderedQuery;
+  /** The source query kind, available without parsing rendered SQL. */
+  readonly queryKind: QueryKind;
+  /** Present when the caller supplied an abort signal to {@link execute} or {@link stream}. */
+  readonly signal?: AbortSignal;
+}
+/** One rendered EXPLAIN statement and the controls passed to an adapter. */
+interface ExplainRequest extends ExecutionRequest {}
+/**
+ * Driver-neutral rows and optional mutation facts returned by an adapter.
+ *
+ * Adapters normalize driver result fields into this shape. They should omit a
+ * mutation fact when the driver cannot report it accurately.
+ */
+interface ExecutionResult<TRow extends object = Record<string, unknown>> {
+  /** Decoded result rows. Mutations without `RETURNING` use an empty array. */
+  readonly rows: readonly TRow[];
+  /** Rows inserted, updated, or deleted when the driver reports that count. */
+  readonly affectedRows?: number | bigint;
+  /** Rows whose stored values changed when distinct from affected rows. */
+  readonly changedRows?: number | bigint;
+  /** An insert identifier reported by the driver, including generated IDs. */
+  readonly insertId?: string | number | bigint;
+}
+/** Adapter-decoded vendor plan rows returned by an EXPLAIN request. */
+interface ExplainResult<TPlanRow extends object = Record<string, unknown>> {
+  /** Opaque plan rows in the shape selected by the application adapter. */
+  readonly rows: readonly TPlanRow[];
+}
+/**
+ * The driver-facing boundary. `request.statement.parameters` contains raw
+ * application values in placeholder order; the adapter binds and encodes them
+ * for its driver. Connection pooling, transactions, retries, and row decoding
+ * remain adapter concerns.
+ */
+interface QueryAdapter {
+  /** Default rendering policy for queries sent through this adapter. */
+  readonly dialect: Dialect;
+  /** Execute one request and normalize the driver's result fields. */
+  execute<TRow extends object>(request: ExecutionRequest): Promise<ExecutionResult<TRow>>;
+}
+/**
+ * An opt-in adapter capability for typed, adapter-decoded EXPLAIN results.
+ *
+ * Qubu renders and validates the statement. The adapter binds parameters,
+ * executes the plan request, owns cancellation and connection lifecycle, and
+ * decodes vendor-specific plan rows without a cross-dialect Qubu plan tree.
+ */
+interface ExplainableQueryAdapter<TPlanRow extends object = Record<string, unknown>> extends QueryAdapter {
+  explain(request: ExplainRequest): Promise<ExplainResult<TPlanRow>>;
+}
+/** Extract the plan-row type owned by an explainable adapter. */
+type ExplainPlanRow<TAdapter extends ExplainableQueryAdapter> = TAdapter extends ExplainableQueryAdapter<infer TPlanRow> ? TPlanRow : never;
+/**
+ * An opt-in adapter capability for streaming rows from read queries.
+ *
+ * The adapter owns the returned iterator and every resource behind it. The
+ * iterator must release those resources when it completes, is closed early,
+ * fails, or observes an aborted request signal.
+ */
+interface StreamingQueryAdapter extends QueryAdapter {
+  /** Return a typed, adapter-owned stream for one SELECT or set query. */
+  stream<TRow extends object>(request: ExecutionRequest): AsyncIterable<TRow>;
+}
+type QueryExecutor = QueryAdapter;
+/**
+ * An adapter that can pin one driver connection for a callback transaction.
+ * The callback receives an adapter scoped to that transaction. Qubu does not
+ * issue transaction SQL or manage the driver's connection lifecycle.
+ */
+interface TransactionalQueryAdapter<TTransactionAdapter extends QueryAdapter = QueryAdapter> extends QueryAdapter {
+  transaction<T>(callback: (adapter: TTransactionAdapter) => Promise<T>, options?: TransactionOptions): Promise<T>;
+}
+/** A transaction-capable streaming adapter whose scoped client can stream. */
+type StreamingTransactionalQueryAdapter = StreamingQueryAdapter & TransactionalQueryAdapter<StreamingQueryAdapter>;
+/** A query client with one application-owned adapter bound to every call. */
+interface QubuClient<TAdapter extends QueryAdapter = QueryAdapter> {
+  /** The adapter supplied to {@link qubu}. */
+  readonly adapter: TAdapter;
+  /** Execute a query and keep the adapter's structured mutation facts. */
+  execute<TRow extends object>(query: Query<TRow, any, any, any>, options?: ExecutionOptions): Promise<ExecutionResult<TRow>>;
+  /** Execute a query and return only its decoded rows. */
+  rows<TRow extends object>(query: Query<TRow, any, any, any>, options?: ExecutionOptions): Promise<readonly TRow[]>;
+}
+/** A bound client whose adapter also decodes vendor-specific EXPLAIN rows. */
+interface QubuExplainableClient<TAdapter extends ExplainableQueryAdapter = ExplainableQueryAdapter> extends QubuClient<TAdapter> {
+  /** Explain a query without executing it and return adapter-owned plan rows. */
+  explain<TQuery extends Query<any, any, any, any>>(query: TQuery, options?: ExplainOptionsFor<TQuery>): Promise<ExplainResult<ExplainPlanRow<TAdapter>>>;
+}
+/** A bound client whose adapter also supports typed read-query streams. */
+interface QubuStreamingClient<TAdapter extends StreamingQueryAdapter = StreamingQueryAdapter> extends QubuClient<TAdapter> {
+  /** Stream decoded rows without materializing the complete result. */
+  stream<TRow extends object>(query: StreamableQuery<TRow>, options?: ExecutionOptions): AsyncIterable<TRow>;
+}
+/** A bound client that supports both streaming and typed EXPLAIN plans. */
+interface QubuStreamingExplainableClient<TAdapter extends StreamingQueryAdapter & ExplainableQueryAdapter = StreamingQueryAdapter & ExplainableQueryAdapter> extends QubuStreamingClient<TAdapter>, QubuExplainableClient<TAdapter> {}
+type QubuClientFor<TAdapter extends QueryAdapter> = TAdapter extends StreamingQueryAdapter ? TAdapter extends ExplainableQueryAdapter ? QubuStreamingExplainableClient<TAdapter> : QubuStreamingClient<TAdapter> : TAdapter extends ExplainableQueryAdapter ? QubuExplainableClient<TAdapter> : QubuClient<TAdapter>;
+/** The client available inside a transaction callback. */
+type QubuTransaction = QubuClient<QueryAdapter>;
+/** The streaming client available inside a streaming transaction callback. */
+type QubuStreamingTransaction = QubuStreamingClient<StreamingQueryAdapter>;
+/** A bound client whose adapter supports transaction-scoped execution. */
+interface QubuTransactionalClient<TAdapter extends TransactionalQueryAdapter = TransactionalQueryAdapter, TTransactionAdapter extends QueryAdapter = QueryAdapter> extends QubuClient<TAdapter> {
+  /** Run several queries on one adapter-owned transaction. */
+  transaction<T>(callback: (transaction: QubuClientFor<TTransactionAdapter>) => Promise<T>, options?: TransactionOptions): Promise<T>;
+}
+/** A bound EXPLAIN client with an adapter-owned transaction callback. */
+type QubuExplainableTransactionalClient<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter = ExplainableQueryAdapter & TransactionalQueryAdapter, TTransactionAdapter extends QueryAdapter = QueryAdapter> = QubuExplainableClient<TAdapter> & QubuTransactionalClient<TAdapter, TTransactionAdapter>;
+/** A bound streaming and EXPLAIN client with an adapter-owned transaction. */
+type QubuExplainableStreamingTransactionalClient<TAdapter extends ExplainableQueryAdapter & StreamingTransactionalQueryAdapter = ExplainableQueryAdapter & StreamingTransactionalQueryAdapter> = QubuStreamingExplainableClient<TAdapter> & QubuTransactionalClient<TAdapter, StreamingQueryAdapter>;
+/** A bound streaming client whose transaction callback can also stream. */
+interface QubuStreamingTransactionalClient<TAdapter extends StreamingTransactionalQueryAdapter = StreamingTransactionalQueryAdapter> extends QubuStreamingClient<TAdapter> {
+  /** Run a callback whose streams must be consumed or closed before it resolves. */
+  transaction<T>(callback: (transaction: QubuStreamingTransaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
+}
+/** Bind an application-owned adapter once for repeated query execution. */
+declare function qubu<TAdapter extends ExplainableQueryAdapter & StreamingTransactionalQueryAdapter>(adapter: TAdapter): QubuExplainableStreamingTransactionalClient<TAdapter>;
+declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuExplainableTransactionalClient<TAdapter> & QubuStreamingExplainableClient<TAdapter>;
+declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter>(adapter: TAdapter): QubuExplainableTransactionalClient<TAdapter>;
+declare function qubu<TAdapter extends ExplainableQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuStreamingExplainableClient<TAdapter>;
+declare function qubu<TAdapter extends ExplainableQueryAdapter>(adapter: TAdapter): QubuExplainableClient<TAdapter>;
+declare function qubu<TAdapter extends StreamingTransactionalQueryAdapter>(adapter: TAdapter): QubuStreamingTransactionalClient<TAdapter>;
+declare function qubu<TAdapter extends TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuTransactionalClient<TAdapter> & QubuStreamingClient<TAdapter>;
+declare function qubu<TAdapter extends TransactionalQueryAdapter>(adapter: TAdapter): QubuTransactionalClient<TAdapter>;
+declare function qubu<TAdapter extends StreamingQueryAdapter>(adapter: TAdapter): QubuStreamingClient<TAdapter>;
+declare function qubu<TAdapter extends QueryAdapter>(adapter: TAdapter): QubuClient<TAdapter>;
+interface DriverValueEncoder<TDriverValue = unknown> {
+  /** Convert one Qubu parameter into the driver's bindable representation. */
+  encode(value: unknown): TDriverValue;
+}
+/**
+ * Render a typed query, pass it to an application adapter, and return the
+ * adapter's structured result unchanged.
+ *
+ * Driver errors are not caught or translated.
+ */
+declare function execute<TRow extends object>(query: Query<TRow, any, any, any>, adapter: QueryAdapter, options?: ExecutionOptions): Promise<ExecutionResult<TRow>>;
+declare function execute<TRow extends object>(adapter: QueryAdapter, query: Query<TRow, any, any, any>, options?: ExecutionOptions): Promise<ExecutionResult<TRow>>;
+/** Execute a query and return its decoded rows without mutation facts. */
+declare function executeRows<TRow extends object>(query: Query<TRow, any, any, any>, adapter: QueryAdapter, options?: ExecutionOptions): Promise<readonly TRow[]>;
+declare function executeRows<TRow extends object>(adapter: QueryAdapter, query: Query<TRow, any, any, any>, options?: ExecutionOptions): Promise<readonly TRow[]>;
+/**
+ * Render a query as a dialect-specific EXPLAIN request and return the
+ * adapter-decoded vendor plan rows. EXPLAIN never calls QueryAdapter.execute.
+ */
+declare function explain<TQuery extends Query<any, any, any, any>, TAdapter extends ExplainableQueryAdapter>(query: TQuery, adapter: TAdapter, options?: ExplainOptionsFor<TQuery>): Promise<ExplainResult<ExplainPlanRow<TAdapter>>>;
+declare function explain<TQuery extends Query<any, any, any, any>, TAdapter extends ExplainableQueryAdapter>(adapter: TAdapter, query: TQuery, options?: ExplainOptionsFor<TQuery>): Promise<ExplainResult<ExplainPlanRow<TAdapter>>>;
+/**
+ * Render a SELECT or set-operation query and return the adapter-owned row
+ * stream. Mutations, including mutations with RETURNING, must use execute().
+ */
+declare function stream<TRow extends object>(query: StreamableQuery<TRow>, adapter: StreamingQueryAdapter, options?: ExecutionOptions): AsyncIterable<TRow>;
+declare function stream<TRow extends object>(adapter: StreamingQueryAdapter, query: StreamableQuery<TRow>, options?: ExecutionOptions): AsyncIterable<TRow>;
+//#endregion
+//#region src/expressions/cast.d.ts
+type CastDefinition = ColumnDefinition<any, false, any, any, false, false, AnySqlType, any, any, any> & {
+  readonly castTarget: CastTarget;
+};
+/**
+ * Cast to a built-in or custom column definition while deriving both result
+ * types from that definition. Operand nullability and source facts survive.
+ */
+declare function cast<TDefinition extends CastDefinition, TExpression extends AnyExpression>(expression: TExpression, definition: TDefinition): ResultExpression<ColumnOutput<TDefinition>, TExpression, 'operator', NullabilityOf<TExpression>, ColumnSqlType<TDefinition>>;
+/** Cast using a type name supplied by the caller or an adapter. */
+declare function cast<T, TSqlType extends AnySqlType = SqlUnknown, TExpression extends AnyExpression = AnyExpression, const TType extends string = string>(expression: TExpression, typeName: TType): ResultExpression<T, TExpression, 'operator', NullabilityOf<TExpression>, TSqlType>;
+/** Create a cast whose JS output and SQL result domain are declared up front. */
+declare function typedCast<T, TSqlType extends AnySqlType>(): <TExpression extends AnyExpression, const TType extends string>(expression: TExpression, typeName: TType) => ResultExpression<T, TExpression, "operator", (MetadataOf<TExpression> extends (infer T_1) ? T_1 extends MetadataOf<TExpression> ? T_1 extends {
+  readonly kind: "result";
+} ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TExpression> extends (infer T_3) ? T_3 extends MetadataOf<TExpression> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) ? T_2 extends {
+  readonly nullableFrom: infer TSource;
+} ? TSource : never : never : never, TSqlType>;
+//#endregion
+//#region src/expressions/value.d.ts
+interface ValueExpression<T = unknown, TSqlType extends AnySqlType = SqlUnknown> extends SchemaExpression<ResultMeta<T, never, TSqlType> | ExpressionMeta<never>, 'value'> {
+  readonly value: T;
+}
+declare function value<T>(input: T): ValueExpression<T>;
+/** Bind a value while declaring its SQL semantic domain. */
+declare function typedValue<TSqlType extends AnySqlType, T>(input: T): ValueExpression<T, TSqlType>;
+declare function asValue<TInput>(input: TInput): TInput extends AnyExpression ? TInput : ValueExpression<TInput>;
+//#endregion
+//#region src/expressions/operators/shared.d.ts
+type Operand<T> = T | ExpressionWithOutput<T>;
+/** Plain values are contextually typed by the expression beside them. */
+type OperandSqlType<T, TContext extends AnySqlType> = T extends Fragment<any> ? SqlTypeOf<T> : TContext;
+/** Type-level validation that a known SQL domain provides a capability. */
+type SqlCapabilityValidation<TActual, TCapability> = SqlTypeSatisfies<TActual, TCapability> extends true ? unknown : QueryTypeValidation<'incompatible-sql-domain', 'expression.sql-domain', 'Use an expression with the required SQL domain.', TActual>;
+/** Type-level validation that two known SQL domains can test equality. */
+type SqlEqualityValidation<TLeft, TRight> = SqlEqualityCompatible<TLeft, TRight> extends true ? unknown : QueryTypeValidation<'incompatible-sql-equality', 'comparison.operands', 'Use operands from the same SQL equality group.', readonly [TLeft, TRight]>;
+/** Type-level validation that two known SQL domains share an ordering group. */
+type SqlOrderValidation<TLeft, TRight> = SqlOrderCompatible<TLeft, TRight> extends true ? unknown : QueryTypeValidation<'incompatible-sql-order', 'comparison.operands', 'Use operands from the same SQL ordering group.', readonly [TLeft, TRight]>;
+type OperandNullability<T> = T extends Fragment<any> ? NullabilityOf<T> : never;
+type IsNullOperand<T> = T extends null ? true : T extends ValueExpression<infer TValue> ? [TValue] extends [null] ? true : false : false;
+//#endregion
+//#region src/expressions/operators/comparison/null.d.ts
+declare function isNull<TExpression extends AnyExpression>(expression: TExpression): ResultExpression<boolean, TExpression, 'operator', never, SqlBoolean>;
+declare function isNotNull<TExpression extends AnyExpression>(expression: TExpression): ResultExpression<boolean, TExpression, 'operator', never, SqlBoolean>;
+declare function isTrue<TExpression extends ExpressionWithOutput<boolean>>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlBoolean>): ResultExpression<boolean, TExpression, "operator", never, SqlBoolean>;
+//#endregion
+//#region src/expressions/operators/comparison/range.d.ts
+type BetweenValidation<TExpression, TLower, TUpper> = SqlOrderValidation<ExpressionSqlType<TExpression>, OperandSqlType<TLower, ExpressionSqlType<TExpression>>> & SqlOrderValidation<ExpressionSqlType<TExpression>, OperandSqlType<TUpper, ExpressionSqlType<TExpression>>>;
+type ListValidation<TExpression, TValues extends readonly unknown[]> = TValues extends readonly [infer THead, ...infer TTail] ? SqlEqualityValidation<ExpressionSqlType<TExpression>, OperandSqlType<THead, ExpressionSqlType<TExpression>>> & ListValidation<TExpression, TTail> : unknown;
+declare function between<T, TExpression extends ExpressionWithOutput<T>, L extends Operand<NoInfer<T>>, H extends Operand<NoInfer<T>>>(expression: TExpression & BetweenValidation<TExpression, L, H>, lower: L, upper: H): ResultExpression<boolean, TExpression | L | H, "operator", NullabilityOf<TExpression | L | H>, SqlBoolean>;
+declare function inList<T, TExpression extends ExpressionWithOutput<T>, const TValues extends readonly Operand<NoInfer<T>>[]>(expression: TExpression & ListValidation<TExpression, TValues>, values: TValues): ResultExpression<boolean, TExpression | TValues[number], "operator", NullabilityOf<TExpression | TValues[number]>, SqlBoolean>;
+declare function notIn<T, TExpression extends ExpressionWithOutput<T>, const TValues extends readonly Operand<NoInfer<T>>[]>(expression: TExpression & ListValidation<TExpression, TValues>, values: TValues): ResultExpression<boolean, TExpression | TValues[number], "operator", NullabilityOf<TExpression | TValues[number]>, SqlBoolean>;
+//#endregion
+//#region src/expressions/operators/comparison/relational.d.ts
+type ComparisonResult<TLeft, R, TOperator extends string> = ResultExpression<boolean, TLeft | R, 'operator', TOperator extends 'IS DISTINCT FROM' | 'IS NOT DISTINCT FROM' ? never : TOperator extends '=' | '<>' ? IsNullOperand<R> extends true ? never : NullabilityOf<TLeft> | OperandNullability<R> : NullabilityOf<TLeft> | OperandNullability<R>, SqlBoolean>;
+/** SQL-domain validation selected by a comparison operator family. */
+type ComparisonValidation<TLeft, TRight, TOperator extends string> = TOperator extends 'LIKE' | 'NOT LIKE' | 'ILIKE' ? SqlCapabilityValidation<ExpressionSqlType<TLeft>, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<TRight, ExpressionSqlType<TLeft>>, SqlTextLike> : TOperator extends '<' | '<=' | '>' | '>=' ? SqlOrderValidation<ExpressionSqlType<TLeft>, OperandSqlType<TRight, ExpressionSqlType<TLeft>>> : SqlEqualityValidation<ExpressionSqlType<TLeft>, OperandSqlType<TRight, ExpressionSqlType<TLeft>>>;
+declare function eq<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, '='>, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+  readonly kind: "result";
+} ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) ? T_2 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_4) ? T_4 extends MetadataOf<TLeft> ? T_4 extends {
+  readonly kind: "result";
+} ? T_4 : never : never : never) extends (infer T_5) ? T_5 extends (MetadataOf<TLeft> extends (infer T_6) ? T_6 extends MetadataOf<TLeft> ? T_6 extends {
+  readonly kind: "result";
+} ? T_6 : never : never : never) ? T_5 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>, R, "=">;
+declare function ne<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, '<>'>, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+  readonly kind: "result";
+} ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) ? T_2 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_4) ? T_4 extends MetadataOf<TLeft> ? T_4 extends {
+  readonly kind: "result";
+} ? T_4 : never : never : never) extends (infer T_5) ? T_5 extends (MetadataOf<TLeft> extends (infer T_6) ? T_6 extends MetadataOf<TLeft> ? T_6 extends {
+  readonly kind: "result";
+} ? T_6 : never : never : never) ? T_5 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>, R, "<>">;
+declare function lt<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, '<'>, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+  readonly kind: "result";
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
+  readonly kind: "result";
+} ? T_2 : never : never : never) ? T_1 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) extends (infer T_4) ? T_4 extends (MetadataOf<TLeft> extends (infer T_5) ? T_5 extends MetadataOf<TLeft> ? T_5 extends {
+  readonly kind: "result";
+} ? T_5 : never : never : never) ? T_4 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>, R, "<">;
+declare function lte<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, '<='>, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+  readonly kind: "result";
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
+  readonly kind: "result";
+} ? T_2 : never : never : never) ? T_1 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) extends (infer T_4) ? T_4 extends (MetadataOf<TLeft> extends (infer T_5) ? T_5 extends MetadataOf<TLeft> ? T_5 extends {
+  readonly kind: "result";
+} ? T_5 : never : never : never) ? T_4 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>, R, "<=">;
+declare function gt<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, '>'>, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+  readonly kind: "result";
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
+  readonly kind: "result";
+} ? T_2 : never : never : never) ? T_1 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) extends (infer T_4) ? T_4 extends (MetadataOf<TLeft> extends (infer T_5) ? T_5 extends MetadataOf<TLeft> ? T_5 extends {
+  readonly kind: "result";
+} ? T_5 : never : never : never) ? T_4 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>, R, ">">;
+declare function gte<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, '>='>, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+  readonly kind: "result";
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
+  readonly kind: "result";
+} ? T_2 : never : never : never) ? T_1 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) extends (infer T_4) ? T_4 extends (MetadataOf<TLeft> extends (infer T_5) ? T_5 extends MetadataOf<TLeft> ? T_5 extends {
+  readonly kind: "result";
+} ? T_5 : never : never : never) ? T_4 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>, R, ">=">;
+declare function like<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, 'LIKE'>, pattern: R): ComparisonResult<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+  readonly kind: "result";
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
+  readonly kind: "result";
+} ? T_2 : never : never : never) ? T_1 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) extends (infer T_4) ? T_4 extends (MetadataOf<TLeft> extends (infer T_5) ? T_5 extends MetadataOf<TLeft> ? T_5 extends {
+  readonly kind: "result";
+} ? T_5 : never : never : never) ? T_4 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlTextLike>, R, "LIKE">;
+declare function notLike<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, 'NOT LIKE'>, pattern: R): ComparisonResult<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+  readonly kind: "result";
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
+  readonly kind: "result";
+} ? T_2 : never : never : never) ? T_1 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) extends (infer T_4) ? T_4 extends (MetadataOf<TLeft> extends (infer T_5) ? T_5 extends MetadataOf<TLeft> ? T_5 extends {
+  readonly kind: "result";
+} ? T_5 : never : never : never) ? T_4 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlTextLike>, R, "NOT LIKE">;
+declare function isDistinctFrom<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, 'IS DISTINCT FROM'>, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+  readonly kind: "result";
+} ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) ? T_2 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_4) ? T_4 extends MetadataOf<TLeft> ? T_4 extends {
+  readonly kind: "result";
+} ? T_4 : never : never : never) extends (infer T_5) ? T_5 extends (MetadataOf<TLeft> extends (infer T_6) ? T_6 extends MetadataOf<TLeft> ? T_6 extends {
+  readonly kind: "result";
+} ? T_6 : never : never : never) ? T_5 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>, R, "IS DISTINCT FROM">;
+declare function isNotDistinctFrom<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, 'IS NOT DISTINCT FROM'>, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+  readonly kind: "result";
+} ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) ? T_2 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_4) ? T_4 extends MetadataOf<TLeft> ? T_4 extends {
+  readonly kind: "result";
+} ? T_4 : never : never : never) extends (infer T_5) ? T_5 extends (MetadataOf<TLeft> extends (infer T_6) ? T_6 extends MetadataOf<TLeft> ? T_6 extends {
+  readonly kind: "result";
+} ? T_6 : never : never : never) ? T_5 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>, R, "IS NOT DISTINCT FROM">;
+//#endregion
+//#region src/expressions/subquery.d.ts
+type SingleColumn<Row extends object> = keyof Row extends (infer TKey) ? TKey extends keyof Row ? [keyof Row] extends [TKey] ? Row[TKey] : never : never : never;
+type ScalarOutput<TQuery extends AnyQuery> = SingleColumn<QueryRow<TQuery>> | ([CardinalityOf<TQuery>] extends ['exactly-one'] ? never : null);
+type SingleColumnSqlType<TQuery extends AnyQuery> = SingleColumn<QuerySqlTypeMap<TQuery>>;
+declare function scalar<TQuery extends AnyQuery>(query: TQuery): Expression<ResultMeta<ScalarOutput<TQuery>, never, SingleColumnSqlType<TQuery>> | InheritedMetadata<TQuery> | SubqueryMeta, 'subquery'>;
+//#endregion
+//#region src/expressions/operators/comparison/subquery.d.ts
+type IsUnion<T, TWhole = T> = T extends unknown ? [TWhole] extends [T] ? false : true : never;
+type InQueryValidation<TExpression, TQuery> = [keyof QueryRow<TQuery>] extends [never] ? QueryTypeValidation<'invalid-subquery', 'in-query.projection', 'Select exactly one field in the IN subquery.'> : true extends IsUnion<keyof QueryRow<TQuery>> ? QueryTypeValidation<'invalid-subquery', 'in-query.projection', 'Select exactly one field in the IN subquery.'> : SingleColumn<QueryRow<TQuery>> extends ExpressionOutput<TExpression> ? SqlEqualityValidation<ExpressionSqlType<TExpression>, SingleColumn<QuerySqlTypeMap<TQuery>>> : QueryTypeValidation<'incompatible-sql-equality', 'in-query.operands', 'Select a subquery field from the same SQL equality group as the expression.', SingleColumn<QueryRow<TQuery>>>;
+declare function inQuery<TExpression extends AnyExpression, TQuery extends Query<any, any, any>>(expression: TExpression & InQueryValidation<TExpression, TQuery>, query: TQuery): SubqueryResultExpression<boolean, TExpression | TQuery, never, SqlBoolean>;
+declare function exists<TQuery extends Query<any, any, any>>(query: TQuery): SubqueryResultExpression<boolean, TQuery, never, SqlBoolean>;
+declare function notExists<TQuery extends Query<any, any, any>>(query: TQuery): SubqueryResultExpression<boolean, TQuery, never, SqlBoolean>;
+//#endregion
+//#region src/expressions/operators/comparison/types.d.ts
+type BooleanExpression<TMetadata = never, TKind extends ExpressionKind = ExpressionKind> = Expression<ResultMeta<boolean, unknown, AnySqlType> | TMetadata, TKind>;
+//#endregion
+//#region src/expressions/case.d.ts
+type CaseSqlType<TThen, TElse> = TThen extends Fragment<any> ? SqlTypeOf<TThen> : TElse extends Fragment<any> ? SqlTypeOf<TElse> : SqlUnknown;
+declare function caseWhen<T, TCondition extends BooleanExpression<any>, TThen extends Operand<T>, TElse extends Operand<T>>(condition: TCondition & SqlCapabilityValidation<ExpressionSqlType<TCondition>, SqlBoolean>, thenValue: TThen & SqlEqualityValidation<OperandSqlType<TThen, CaseSqlType<TThen, TElse>>, OperandSqlType<TElse, CaseSqlType<TThen, TElse>>>, elseValue: TElse): ResultExpression<T, TCondition | TThen | TElse, "operator", OperandNullability<TThen> | OperandNullability<TElse>, CaseSqlType<TThen, TElse>>;
+//#endregion
+//#region src/expressions/sql.d.ts
+type SqlChild<TValues extends readonly unknown[]> = Extract<TValues[number], AnyFragment>;
+type EmbeddedQueryMetadata<TChild> = TChild extends AnyQuery ? SubqueryMeta : never;
+/**
+ * A parameterized SQL template that composes with Qubu expressions and
+ * queries through the normal renderer.
+ */
+type SqlFragment<TOutput = unknown, TSqlType extends AnySqlType = SqlUnknown, TChild extends AnyFragment = never> = Expression<ResultMeta<TOutput, NullabilityOf<TChild>, TSqlType> | ExpressionMeta<DependenciesOf<TChild>> | InheritedMetadata<TChild> | EmbeddedQueryMetadata<TChild>, 'sql'>;
+/** A SQL template tag with an explicitly declared output and SQL domain. */
+interface TypedSqlTag<TOutput, TSqlType extends AnySqlType = SqlUnknown> {
+  <const TValues extends readonly unknown[]>(strings: TemplateStringsArray, ...values: TValues): SqlFragment<TOutput, TSqlType, SqlChild<TValues>>;
+}
+/** Public call contract for {@link sql}. */
+interface SqlTag extends TypedSqlTag<unknown, SqlUnknown> {
+  /**
+   * Declare the application output and SQL semantic domain without changing
+   * how template substitutions render.
+   */
+  type<TOutput, TSqlType extends AnySqlType = SqlUnknown>(): TypedSqlTag<TOutput, TSqlType>;
+}
+/**
+ * Build trusted SQL syntax while binding every ordinary substitution as a
+ * parameter. Qubu fragments remain composable substitutions.
+ *
+ * @remarks Template text is trusted and is not parsed. Use `identifier()` from
+ * `qubu/core` for runtime identifiers and `unsafeExpression()` for deliberately
+ * dynamic syntax. Use `sql.type<Output, SqlType>()` when the fragment's result
+ * is known.
+ */
+declare const sql: SqlTag;
+//#endregion
+//#region src/expressions/functions/aggregate.d.ts
+declare function count(): AggregateResultExpression<number, never, 'function', never, SqlInteger>;
+declare function count<TExpression extends AnyExpression>(expression: TExpression): AggregateResultExpression<number, TExpression, 'function', never, SqlInteger>;
+declare function countDistinct<TExpression extends AnyExpression>(expression: TExpression): AggregateResultExpression<number, TExpression, "function", never, SqlInteger>;
+declare function sum<T, TExpression extends ExpressionWithOutput<T>>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlNumericLike>): AggregateResultExpression<ExpressionOutput<TExpression>, TExpression, "function", NullabilityOf<TExpression>, ExpressionSqlType<TExpression>>;
+declare function avg<T, TExpression extends ExpressionWithOutput<T>>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlNumericLike>): AggregateResultExpression<number, TExpression, "function", NullabilityOf<TExpression>, SqlDecimal>;
+declare function min<T, TExpression extends ExpressionWithOutput<T>>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable>): AggregateResultExpression<ExpressionOutput<TExpression>, TExpression, "function", NullabilityOf<TExpression>, ExpressionSqlType<TExpression>>;
+declare function max<T, TExpression extends ExpressionWithOutput<T>>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable>): AggregateResultExpression<ExpressionOutput<TExpression>, TExpression, "function", NullabilityOf<TExpression>, ExpressionSqlType<TExpression>>;
+//#endregion
+//#region src/expressions/functions/call.d.ts
+declare function call<TOutput = unknown, const TName extends string = string, const TArguments extends readonly unknown[] = readonly unknown[], TNullableFrom = NullabilityOf<TArguments[number]>, TSqlType extends AnySqlType = SqlUnknown>(name: TName, ...args: TArguments): Expression<ResultMeta<TOutput, TNullableFrom, TSqlType> | ExpressionMeta<DependenciesOf<TArguments[number]>> | InheritedMetadata<TArguments[number]>, "function">;
+/**
+ * Internal built-in function constructor for deterministic schema functions.
+ * Arbitrary calls stay on {@link call} and require an explicit schema
+ * extension contract before they can be used in schema metadata.
+ */
+declare function schemaCall<TOutput = unknown, const TName extends string = string, const TArguments extends readonly unknown[] = readonly unknown[], TNullableFrom = NullabilityOf<TArguments[number]>, TSqlType extends AnySqlType = SqlUnknown>(name: TName, ...args: TArguments): SchemaExpression<ResultMeta<TOutput, TNullableFrom, TSqlType> | ExpressionMeta<DependenciesOf<TArguments[number]>> | InheritedMetadata<TArguments[number]>, "function">;
+/** Declare the SQL result domain of a custom function call. */
+declare function typedCall<TSqlType extends AnySqlType, TOutput = unknown>(): <const TName extends string, const TArguments extends readonly unknown[]>(name: TName, ...args: TArguments) => Expression<ResultMeta<TOutput, NullabilityOf<TArguments[number]>, TSqlType> | ExpressionMeta<MetadataOf<TArguments[number]> extends (infer T) ? T extends MetadataOf<TArguments[number]> ? T extends {
+  readonly kind: "expression";
+  readonly dependencies: infer TDependencies;
+} ? TDependencies : never : never : never> | (MetadataOf<TArguments[number]> extends (infer T_1) ? T_1 extends MetadataOf<TArguments[number]> ? T_1 extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T_1 : never : never), "function">;
+//#endregion
+//#region src/expressions/functions/string.d.ts
+type TextArgumentsValidation<TArguments extends readonly unknown[]> = TArguments extends readonly [infer THead, ...infer TTail] ? SqlCapabilityValidation<OperandSqlType<THead, SqlText>, SqlTextLike> & TextArgumentsValidation<TTail> : unknown;
+type CoalesceValidation<TFirst, TRest extends readonly unknown[]> = TRest extends readonly [infer THead, ...infer TTail] ? SqlEqualityValidation<ExpressionSqlType<TFirst>, ExpressionSqlType<THead>> & CoalesceValidation<TFirst, TTail> : unknown;
+declare function lower<TExpression extends ExpressionWithOutput<string>>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlTextLike>): SchemaExpression<ResultMeta<string, (MetadataOf<TExpression> extends (infer T) ? T extends MetadataOf<TExpression> ? T extends {
+  readonly kind: "result";
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TExpression> extends (infer T_2) ? T_2 extends MetadataOf<TExpression> ? T_2 extends {
+  readonly kind: "result";
+} ? T_2 : never : never : never) ? T_1 extends {
+  readonly nullableFrom: infer TSource;
+} ? TSource : never : never : never, SqlText> | ExpressionMeta<MetadataOf<TExpression> extends (infer T_3) ? T_3 extends MetadataOf<TExpression> ? T_3 extends {
+  readonly kind: "expression";
+  readonly dependencies: infer TDependencies;
+} ? TDependencies : never : never : never> | (MetadataOf<TExpression> extends (infer T_4) ? T_4 extends MetadataOf<TExpression> ? T_4 extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T_4 : never : never), "function">;
+declare function upper<TExpression extends ExpressionWithOutput<string>>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlTextLike>): SchemaExpression<ResultMeta<string, (MetadataOf<TExpression> extends (infer T) ? T extends MetadataOf<TExpression> ? T extends {
+  readonly kind: "result";
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TExpression> extends (infer T_2) ? T_2 extends MetadataOf<TExpression> ? T_2 extends {
+  readonly kind: "result";
+} ? T_2 : never : never : never) ? T_1 extends {
+  readonly nullableFrom: infer TSource;
+} ? TSource : never : never : never, SqlText> | ExpressionMeta<MetadataOf<TExpression> extends (infer T_3) ? T_3 extends MetadataOf<TExpression> ? T_3 extends {
+  readonly kind: "expression";
+  readonly dependencies: infer TDependencies;
+} ? TDependencies : never : never : never> | (MetadataOf<TExpression> extends (infer T_4) ? T_4 extends MetadataOf<TExpression> ? T_4 extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T_4 : never : never), "function">;
+declare function coalesce<T, const TExpressions extends readonly [ExpressionWithOutput<T>, ...ExpressionWithOutput<T>[]]>(...expressions: TExpressions & CoalesceValidation<TExpressions[0], TExpressions extends readonly [any, ...infer TRest] ? TRest : never>): SchemaExpression<ResultMeta<T, never, ExpressionSqlType<TExpressions[0]>> | ExpressionMeta<MetadataOf<TExpressions[number]> extends (infer T_1) ? T_1 extends MetadataOf<TExpressions[number]> ? T_1 extends {
+  readonly kind: "expression";
+  readonly dependencies: infer TDependencies;
+} ? TDependencies : never : never : never> | (MetadataOf<TExpressions[number]> extends (infer T_2) ? T_2 extends MetadataOf<TExpressions[number]> ? T_2 extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T_2 : never : never), "function">;
+declare function concat<const TArguments extends readonly Operand<string>[]>(...argumentsToConcat: TArguments & TextArgumentsValidation<TArguments>): SchemaExpression<ResultMeta<string, (MetadataOf<TArguments[number]> extends (infer T) ? T extends MetadataOf<TArguments[number]> ? T extends {
+  readonly kind: "result";
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TArguments[number]> extends (infer T_2) ? T_2 extends MetadataOf<TArguments[number]> ? T_2 extends {
+  readonly kind: "result";
+} ? T_2 : never : never : never) ? T_1 extends {
+  readonly nullableFrom: infer TSource;
+} ? TSource : never : never : never, SqlText> | ExpressionMeta<MetadataOf<TArguments[number]> extends (infer T_3) ? T_3 extends MetadataOf<TArguments[number]> ? T_3 extends {
+  readonly kind: "expression";
+  readonly dependencies: infer TDependencies;
+} ? TDependencies : never : never : never> | (MetadataOf<TArguments[number]> extends (infer T_4) ? T_4 extends MetadataOf<TArguments[number]> ? T_4 extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T_4 : never : never), "function">;
+//#endregion
+//#region src/expressions/functions/window.d.ts
+type WindowOrder = AnyExpression | OrderTerm<any>;
+/**
+ * The initial inline window scope. Named windows and frame clauses can be
+ * added at a later dialect-aware boundary without changing expression types.
+ */
+interface WindowSpec {
+  readonly partitionBy?: readonly AnyExpression[];
+  readonly orderBy?: readonly WindowOrder[];
+}
+type FragmentItems<T> = T extends readonly unknown[] ? T[number] : never;
+type WindowSpecParts<TWindow> = TWindow extends WindowSpec ? FragmentItems<TWindow['partitionBy']> | FragmentItems<TWindow['orderBy']> : never;
+type WindowedExpression<TExpression extends AnyExpression, TWindow extends WindowSpec | undefined> = Expression<ResultMeta<OutputOf<TExpression>, NullabilityOf<TExpression>, SqlTypeOf<TExpression>> | ExpressionMeta<DependenciesOf<TExpression | WindowSpecParts<TWindow>>> | InheritedMetadata<TExpression | WindowSpecParts<TWindow>> | WindowMeta, 'function'>;
+declare function over<TExpression extends AnyExpression, const TWindow extends WindowSpec | undefined = undefined>(expression: TExpression, window?: TWindow): WindowedExpression<TExpression, TWindow>;
+declare function rowNumber(): Expression<ExpressionMeta<never> | ResultMeta<number, never, SqlInteger>, "function">;
+declare function rank(): Expression<ExpressionMeta<never> | ResultMeta<number, never, SqlInteger>, "function">;
+declare function denseRank(): Expression<ExpressionMeta<never> | ResultMeta<number, never, SqlInteger>, "function">;
+//#endregion
+//#region src/expressions/json.d.ts
+/** One safely encoded object key or zero-based array index in a JSON path. */
+type JsonPathSegment = string | number;
+declare const jsonPathBrand: unique symbol;
+/** An opaque root-relative JSON path whose literal segments remain available to TypeScript. */
+interface JsonPath<TSegments extends readonly JsonPathSegment[] = readonly JsonPathSegment[]> {
+  readonly [jsonPathBrand]: true;
+  readonly pathKind: 'json';
+  readonly segments: TSegments;
+}
+/**
+ * Build a root-relative JSON path from object keys and array indexes.
+ *
+ * @throws {TypeError} When an index is negative, fractional, or unsafe.
+ */
+declare function jsonPath<const TSegments extends readonly JsonPathSegment[]>(...segments: TSegments): JsonPath<TSegments>;
+type JsonExpressionMetadata<TOutput, TDocument> = ResultMeta<TOutput> | ExpressionMeta<DependenciesOf<TDocument>> | InheritedMetadata<TDocument> | RequiresCapabilityMeta<'json'>;
+/** Extract a JSON string, returning SQL NULL for missing, null, or non-string values. */
+declare function jsonText<TDocument extends AnyExpression, TPath extends JsonPath>(document: TDocument, path: TPath): SchemaExpression<JsonExpressionMetadata<string | null, TDocument>, "function">;
+/** Extract a JSON number, returning SQL NULL for missing, null, or non-number values. */
+declare function jsonNumber<TDocument extends AnyExpression, TPath extends JsonPath>(document: TDocument, path: TPath): SchemaExpression<JsonExpressionMetadata<number | null, TDocument>, "function">;
+/** Extract a JSON boolean, returning SQL NULL for missing, null, or non-boolean values. */
+declare function jsonBoolean<TDocument extends AnyExpression, TPath extends JsonPath>(document: TDocument, path: TPath): SchemaExpression<JsonExpressionMetadata<boolean | null, TDocument>, "function">;
+/** Test whether a path exists, including when its value is JSON null. */
+declare function jsonExists<TDocument extends AnyExpression, TPath extends JsonPath>(document: TDocument, path: TPath): SchemaExpression<JsonExpressionMetadata<boolean, TDocument>, "function">;
+//#endregion
+//#region src/expressions/operators/arithmetic.d.ts
+type ArithmeticValidation<TLeft, TRight> = SqlCapabilityValidation<ExpressionSqlType<TLeft>, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<TRight, ExpressionSqlType<TLeft>>, SqlNumericLike> & SqlOrderValidation<ExpressionSqlType<TLeft>, OperandSqlType<TRight, ExpressionSqlType<TLeft>>>;
+declare const add: <T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ArithmeticValidation<TLeft, R>, right: R) => ResultExpression<unknown, R | (TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+  readonly kind: "result";
+} ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) ? T_2 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_4) ? T_4 extends MetadataOf<TLeft> ? T_4 extends {
+  readonly kind: "result";
+} ? T_4 : never : never : never) extends (infer T_5) ? T_5 extends (MetadataOf<TLeft> extends (infer T_6) ? T_6 extends MetadataOf<TLeft> ? T_6 extends {
+  readonly kind: "result";
+} ? T_6 : never : never : never) ? T_5 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_7) ? T_7 extends MetadataOf<TLeft> ? T_7 extends {
+  readonly kind: "result";
+} ? T_7 : never : never : never) extends (infer T_8) ? T_8 extends (MetadataOf<TLeft> extends (infer T_9) ? T_9 extends MetadataOf<TLeft> ? T_9 extends {
+  readonly kind: "result";
+} ? T_9 : never : never : never) ? T_8 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_10) ? T_10 extends MetadataOf<TLeft> ? T_10 extends {
+  readonly kind: "result";
+} ? T_10 : never : never : never) extends (infer T_11) ? T_11 extends (MetadataOf<TLeft> extends (infer T_12) ? T_12 extends MetadataOf<TLeft> ? T_12 extends {
+  readonly kind: "result";
+} ? T_12 : never : never : never) ? T_11 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>), "operator", NullabilityOf<R | (TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_13) ? T_13 extends MetadataOf<TLeft> ? T_13 extends {
+  readonly kind: "result";
+} ? T_13 : never : never : never) extends (infer T_14) ? T_14 extends (MetadataOf<TLeft> extends (infer T_15) ? T_15 extends MetadataOf<TLeft> ? T_15 extends {
+  readonly kind: "result";
+} ? T_15 : never : never : never) ? T_14 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_16) ? T_16 extends MetadataOf<TLeft> ? T_16 extends {
+  readonly kind: "result";
+} ? T_16 : never : never : never) extends (infer T_17) ? T_17 extends (MetadataOf<TLeft> extends (infer T_18) ? T_18 extends MetadataOf<TLeft> ? T_18 extends {
+  readonly kind: "result";
+} ? T_18 : never : never : never) ? T_17 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_19) ? T_19 extends MetadataOf<TLeft> ? T_19 extends {
+  readonly kind: "result";
+} ? T_19 : never : never : never) extends (infer T_20) ? T_20 extends (MetadataOf<TLeft> extends (infer T_21) ? T_21 extends MetadataOf<TLeft> ? T_21 extends {
+  readonly kind: "result";
+} ? T_21 : never : never : never) ? T_20 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_22) ? T_22 extends MetadataOf<TLeft> ? T_22 extends {
+  readonly kind: "result";
+} ? T_22 : never : never : never) extends (infer T_23) ? T_23 extends (MetadataOf<TLeft> extends (infer T_24) ? T_24 extends MetadataOf<TLeft> ? T_24 extends {
+  readonly kind: "result";
+} ? T_24 : never : never : never) ? T_23 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>)>, (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_25) ? T_25 extends MetadataOf<TLeft> ? T_25 extends {
+  readonly kind: "result";
+} ? T_25 : never : never : never) extends (infer T_26) ? T_26 extends (MetadataOf<TLeft> extends (infer T_27) ? T_27 extends MetadataOf<TLeft> ? T_27 extends {
+  readonly kind: "result";
+} ? T_27 : never : never : never) ? T_26 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_28) ? T_28 extends MetadataOf<TLeft> ? T_28 extends {
+  readonly kind: "result";
+} ? T_28 : never : never : never) extends (infer T_29) ? T_29 extends (MetadataOf<TLeft> extends (infer T_30) ? T_30 extends MetadataOf<TLeft> ? T_30 extends {
+  readonly kind: "result";
+} ? T_30 : never : never : never) ? T_29 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_31) ? T_31 extends MetadataOf<TLeft> ? T_31 extends {
+  readonly kind: "result";
+} ? T_31 : never : never : never) extends (infer T_32) ? T_32 extends (MetadataOf<TLeft> extends (infer T_33) ? T_33 extends MetadataOf<TLeft> ? T_33 extends {
+  readonly kind: "result";
+} ? T_33 : never : never : never) ? T_32 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_34) ? T_34 extends MetadataOf<TLeft> ? T_34 extends {
+  readonly kind: "result";
+} ? T_34 : never : never : never) extends (infer T_35) ? T_35 extends (MetadataOf<TLeft> extends (infer T_36) ? T_36 extends MetadataOf<TLeft> ? T_36 extends {
+  readonly kind: "result";
+} ? T_36 : never : never : never) ? T_35 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> extends (infer T_37) ? T_37 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_38) ? T_38 extends MetadataOf<TLeft> ? T_38 extends {
+  readonly kind: "result";
+} ? T_38 : never : never : never) extends (infer T_39) ? T_39 extends (MetadataOf<TLeft> extends (infer T_40) ? T_40 extends MetadataOf<TLeft> ? T_40 extends {
+  readonly kind: "result";
+} ? T_40 : never : never : never) ? T_39 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_41) ? T_41 extends MetadataOf<TLeft> ? T_41 extends {
+  readonly kind: "result";
+} ? T_41 : never : never : never) extends (infer T_42) ? T_42 extends (MetadataOf<TLeft> extends (infer T_43) ? T_43 extends MetadataOf<TLeft> ? T_43 extends {
+  readonly kind: "result";
+} ? T_43 : never : never : never) ? T_42 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_44) ? T_44 extends MetadataOf<TLeft> ? T_44 extends {
+  readonly kind: "result";
+} ? T_44 : never : never : never) extends (infer T_45) ? T_45 extends (MetadataOf<TLeft> extends (infer T_46) ? T_46 extends MetadataOf<TLeft> ? T_46 extends {
+  readonly kind: "result";
+} ? T_46 : never : never : never) ? T_45 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_47) ? T_47 extends MetadataOf<TLeft> ? T_47 extends {
+  readonly kind: "result";
+} ? T_47 : never : never : never) extends (infer T_48) ? T_48 extends (MetadataOf<TLeft> extends (infer T_49) ? T_49 extends MetadataOf<TLeft> ? T_49 extends {
+  readonly kind: "result";
+} ? T_49 : never : never : never) ? T_48 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> ? T_37 extends {
+  readonly kind: "result";
+} ? T_37 : never : never : never) extends (infer T_50) ? T_50 extends (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_51) ? T_51 extends MetadataOf<TLeft> ? T_51 extends {
+  readonly kind: "result";
+} ? T_51 : never : never : never) extends (infer T_52) ? T_52 extends (MetadataOf<TLeft> extends (infer T_53) ? T_53 extends MetadataOf<TLeft> ? T_53 extends {
+  readonly kind: "result";
+} ? T_53 : never : never : never) ? T_52 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_54) ? T_54 extends MetadataOf<TLeft> ? T_54 extends {
+  readonly kind: "result";
+} ? T_54 : never : never : never) extends (infer T_55) ? T_55 extends (MetadataOf<TLeft> extends (infer T_56) ? T_56 extends MetadataOf<TLeft> ? T_56 extends {
+  readonly kind: "result";
+} ? T_56 : never : never : never) ? T_55 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_57) ? T_57 extends MetadataOf<TLeft> ? T_57 extends {
+  readonly kind: "result";
+} ? T_57 : never : never : never) extends (infer T_58) ? T_58 extends (MetadataOf<TLeft> extends (infer T_59) ? T_59 extends MetadataOf<TLeft> ? T_59 extends {
+  readonly kind: "result";
+} ? T_59 : never : never : never) ? T_58 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_60) ? T_60 extends MetadataOf<TLeft> ? T_60 extends {
+  readonly kind: "result";
+} ? T_60 : never : never : never) extends (infer T_61) ? T_61 extends (MetadataOf<TLeft> extends (infer T_62) ? T_62 extends MetadataOf<TLeft> ? T_62 extends {
+  readonly kind: "result";
+} ? T_62 : never : never : never) ? T_61 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> extends (infer T_63) ? T_63 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_64) ? T_64 extends MetadataOf<TLeft> ? T_64 extends {
+  readonly kind: "result";
+} ? T_64 : never : never : never) extends (infer T_65) ? T_65 extends (MetadataOf<TLeft> extends (infer T_66) ? T_66 extends MetadataOf<TLeft> ? T_66 extends {
+  readonly kind: "result";
+} ? T_66 : never : never : never) ? T_65 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_67) ? T_67 extends MetadataOf<TLeft> ? T_67 extends {
+  readonly kind: "result";
+} ? T_67 : never : never : never) extends (infer T_68) ? T_68 extends (MetadataOf<TLeft> extends (infer T_69) ? T_69 extends MetadataOf<TLeft> ? T_69 extends {
+  readonly kind: "result";
+} ? T_69 : never : never : never) ? T_68 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_70) ? T_70 extends MetadataOf<TLeft> ? T_70 extends {
+  readonly kind: "result";
+} ? T_70 : never : never : never) extends (infer T_71) ? T_71 extends (MetadataOf<TLeft> extends (infer T_72) ? T_72 extends MetadataOf<TLeft> ? T_72 extends {
+  readonly kind: "result";
+} ? T_72 : never : never : never) ? T_71 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_73) ? T_73 extends MetadataOf<TLeft> ? T_73 extends {
+  readonly kind: "result";
+} ? T_73 : never : never : never) extends (infer T_74) ? T_74 extends (MetadataOf<TLeft> extends (infer T_75) ? T_75 extends MetadataOf<TLeft> ? T_75 extends {
+  readonly kind: "result";
+} ? T_75 : never : never : never) ? T_74 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> ? T_63 extends {
+  readonly kind: "result";
+} ? T_63 : never : never : never) ? T_50 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>;
+declare const subtract: <T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ArithmeticValidation<TLeft, R>, right: R) => ResultExpression<unknown, R | (TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+  readonly kind: "result";
+} ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) ? T_2 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_4) ? T_4 extends MetadataOf<TLeft> ? T_4 extends {
+  readonly kind: "result";
+} ? T_4 : never : never : never) extends (infer T_5) ? T_5 extends (MetadataOf<TLeft> extends (infer T_6) ? T_6 extends MetadataOf<TLeft> ? T_6 extends {
+  readonly kind: "result";
+} ? T_6 : never : never : never) ? T_5 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_7) ? T_7 extends MetadataOf<TLeft> ? T_7 extends {
+  readonly kind: "result";
+} ? T_7 : never : never : never) extends (infer T_8) ? T_8 extends (MetadataOf<TLeft> extends (infer T_9) ? T_9 extends MetadataOf<TLeft> ? T_9 extends {
+  readonly kind: "result";
+} ? T_9 : never : never : never) ? T_8 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_10) ? T_10 extends MetadataOf<TLeft> ? T_10 extends {
+  readonly kind: "result";
+} ? T_10 : never : never : never) extends (infer T_11) ? T_11 extends (MetadataOf<TLeft> extends (infer T_12) ? T_12 extends MetadataOf<TLeft> ? T_12 extends {
+  readonly kind: "result";
+} ? T_12 : never : never : never) ? T_11 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>), "operator", NullabilityOf<R | (TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_13) ? T_13 extends MetadataOf<TLeft> ? T_13 extends {
+  readonly kind: "result";
+} ? T_13 : never : never : never) extends (infer T_14) ? T_14 extends (MetadataOf<TLeft> extends (infer T_15) ? T_15 extends MetadataOf<TLeft> ? T_15 extends {
+  readonly kind: "result";
+} ? T_15 : never : never : never) ? T_14 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_16) ? T_16 extends MetadataOf<TLeft> ? T_16 extends {
+  readonly kind: "result";
+} ? T_16 : never : never : never) extends (infer T_17) ? T_17 extends (MetadataOf<TLeft> extends (infer T_18) ? T_18 extends MetadataOf<TLeft> ? T_18 extends {
+  readonly kind: "result";
+} ? T_18 : never : never : never) ? T_17 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_19) ? T_19 extends MetadataOf<TLeft> ? T_19 extends {
+  readonly kind: "result";
+} ? T_19 : never : never : never) extends (infer T_20) ? T_20 extends (MetadataOf<TLeft> extends (infer T_21) ? T_21 extends MetadataOf<TLeft> ? T_21 extends {
+  readonly kind: "result";
+} ? T_21 : never : never : never) ? T_20 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_22) ? T_22 extends MetadataOf<TLeft> ? T_22 extends {
+  readonly kind: "result";
+} ? T_22 : never : never : never) extends (infer T_23) ? T_23 extends (MetadataOf<TLeft> extends (infer T_24) ? T_24 extends MetadataOf<TLeft> ? T_24 extends {
+  readonly kind: "result";
+} ? T_24 : never : never : never) ? T_23 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>)>, (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_25) ? T_25 extends MetadataOf<TLeft> ? T_25 extends {
+  readonly kind: "result";
+} ? T_25 : never : never : never) extends (infer T_26) ? T_26 extends (MetadataOf<TLeft> extends (infer T_27) ? T_27 extends MetadataOf<TLeft> ? T_27 extends {
+  readonly kind: "result";
+} ? T_27 : never : never : never) ? T_26 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_28) ? T_28 extends MetadataOf<TLeft> ? T_28 extends {
+  readonly kind: "result";
+} ? T_28 : never : never : never) extends (infer T_29) ? T_29 extends (MetadataOf<TLeft> extends (infer T_30) ? T_30 extends MetadataOf<TLeft> ? T_30 extends {
+  readonly kind: "result";
+} ? T_30 : never : never : never) ? T_29 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_31) ? T_31 extends MetadataOf<TLeft> ? T_31 extends {
+  readonly kind: "result";
+} ? T_31 : never : never : never) extends (infer T_32) ? T_32 extends (MetadataOf<TLeft> extends (infer T_33) ? T_33 extends MetadataOf<TLeft> ? T_33 extends {
+  readonly kind: "result";
+} ? T_33 : never : never : never) ? T_32 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_34) ? T_34 extends MetadataOf<TLeft> ? T_34 extends {
+  readonly kind: "result";
+} ? T_34 : never : never : never) extends (infer T_35) ? T_35 extends (MetadataOf<TLeft> extends (infer T_36) ? T_36 extends MetadataOf<TLeft> ? T_36 extends {
+  readonly kind: "result";
+} ? T_36 : never : never : never) ? T_35 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> extends (infer T_37) ? T_37 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_38) ? T_38 extends MetadataOf<TLeft> ? T_38 extends {
+  readonly kind: "result";
+} ? T_38 : never : never : never) extends (infer T_39) ? T_39 extends (MetadataOf<TLeft> extends (infer T_40) ? T_40 extends MetadataOf<TLeft> ? T_40 extends {
+  readonly kind: "result";
+} ? T_40 : never : never : never) ? T_39 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_41) ? T_41 extends MetadataOf<TLeft> ? T_41 extends {
+  readonly kind: "result";
+} ? T_41 : never : never : never) extends (infer T_42) ? T_42 extends (MetadataOf<TLeft> extends (infer T_43) ? T_43 extends MetadataOf<TLeft> ? T_43 extends {
+  readonly kind: "result";
+} ? T_43 : never : never : never) ? T_42 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_44) ? T_44 extends MetadataOf<TLeft> ? T_44 extends {
+  readonly kind: "result";
+} ? T_44 : never : never : never) extends (infer T_45) ? T_45 extends (MetadataOf<TLeft> extends (infer T_46) ? T_46 extends MetadataOf<TLeft> ? T_46 extends {
+  readonly kind: "result";
+} ? T_46 : never : never : never) ? T_45 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_47) ? T_47 extends MetadataOf<TLeft> ? T_47 extends {
+  readonly kind: "result";
+} ? T_47 : never : never : never) extends (infer T_48) ? T_48 extends (MetadataOf<TLeft> extends (infer T_49) ? T_49 extends MetadataOf<TLeft> ? T_49 extends {
+  readonly kind: "result";
+} ? T_49 : never : never : never) ? T_48 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> ? T_37 extends {
+  readonly kind: "result";
+} ? T_37 : never : never : never) extends (infer T_50) ? T_50 extends (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_51) ? T_51 extends MetadataOf<TLeft> ? T_51 extends {
+  readonly kind: "result";
+} ? T_51 : never : never : never) extends (infer T_52) ? T_52 extends (MetadataOf<TLeft> extends (infer T_53) ? T_53 extends MetadataOf<TLeft> ? T_53 extends {
+  readonly kind: "result";
+} ? T_53 : never : never : never) ? T_52 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_54) ? T_54 extends MetadataOf<TLeft> ? T_54 extends {
+  readonly kind: "result";
+} ? T_54 : never : never : never) extends (infer T_55) ? T_55 extends (MetadataOf<TLeft> extends (infer T_56) ? T_56 extends MetadataOf<TLeft> ? T_56 extends {
+  readonly kind: "result";
+} ? T_56 : never : never : never) ? T_55 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_57) ? T_57 extends MetadataOf<TLeft> ? T_57 extends {
+  readonly kind: "result";
+} ? T_57 : never : never : never) extends (infer T_58) ? T_58 extends (MetadataOf<TLeft> extends (infer T_59) ? T_59 extends MetadataOf<TLeft> ? T_59 extends {
+  readonly kind: "result";
+} ? T_59 : never : never : never) ? T_58 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_60) ? T_60 extends MetadataOf<TLeft> ? T_60 extends {
+  readonly kind: "result";
+} ? T_60 : never : never : never) extends (infer T_61) ? T_61 extends (MetadataOf<TLeft> extends (infer T_62) ? T_62 extends MetadataOf<TLeft> ? T_62 extends {
+  readonly kind: "result";
+} ? T_62 : never : never : never) ? T_61 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> extends (infer T_63) ? T_63 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_64) ? T_64 extends MetadataOf<TLeft> ? T_64 extends {
+  readonly kind: "result";
+} ? T_64 : never : never : never) extends (infer T_65) ? T_65 extends (MetadataOf<TLeft> extends (infer T_66) ? T_66 extends MetadataOf<TLeft> ? T_66 extends {
+  readonly kind: "result";
+} ? T_66 : never : never : never) ? T_65 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_67) ? T_67 extends MetadataOf<TLeft> ? T_67 extends {
+  readonly kind: "result";
+} ? T_67 : never : never : never) extends (infer T_68) ? T_68 extends (MetadataOf<TLeft> extends (infer T_69) ? T_69 extends MetadataOf<TLeft> ? T_69 extends {
+  readonly kind: "result";
+} ? T_69 : never : never : never) ? T_68 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_70) ? T_70 extends MetadataOf<TLeft> ? T_70 extends {
+  readonly kind: "result";
+} ? T_70 : never : never : never) extends (infer T_71) ? T_71 extends (MetadataOf<TLeft> extends (infer T_72) ? T_72 extends MetadataOf<TLeft> ? T_72 extends {
+  readonly kind: "result";
+} ? T_72 : never : never : never) ? T_71 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_73) ? T_73 extends MetadataOf<TLeft> ? T_73 extends {
+  readonly kind: "result";
+} ? T_73 : never : never : never) extends (infer T_74) ? T_74 extends (MetadataOf<TLeft> extends (infer T_75) ? T_75 extends MetadataOf<TLeft> ? T_75 extends {
+  readonly kind: "result";
+} ? T_75 : never : never : never) ? T_74 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> ? T_63 extends {
+  readonly kind: "result";
+} ? T_63 : never : never : never) ? T_50 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>;
+declare const multiply: <T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ArithmeticValidation<TLeft, R>, right: R) => ResultExpression<unknown, R | (TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+  readonly kind: "result";
+} ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) ? T_2 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_4) ? T_4 extends MetadataOf<TLeft> ? T_4 extends {
+  readonly kind: "result";
+} ? T_4 : never : never : never) extends (infer T_5) ? T_5 extends (MetadataOf<TLeft> extends (infer T_6) ? T_6 extends MetadataOf<TLeft> ? T_6 extends {
+  readonly kind: "result";
+} ? T_6 : never : never : never) ? T_5 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_7) ? T_7 extends MetadataOf<TLeft> ? T_7 extends {
+  readonly kind: "result";
+} ? T_7 : never : never : never) extends (infer T_8) ? T_8 extends (MetadataOf<TLeft> extends (infer T_9) ? T_9 extends MetadataOf<TLeft> ? T_9 extends {
+  readonly kind: "result";
+} ? T_9 : never : never : never) ? T_8 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_10) ? T_10 extends MetadataOf<TLeft> ? T_10 extends {
+  readonly kind: "result";
+} ? T_10 : never : never : never) extends (infer T_11) ? T_11 extends (MetadataOf<TLeft> extends (infer T_12) ? T_12 extends MetadataOf<TLeft> ? T_12 extends {
+  readonly kind: "result";
+} ? T_12 : never : never : never) ? T_11 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>), "operator", NullabilityOf<R | (TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_13) ? T_13 extends MetadataOf<TLeft> ? T_13 extends {
+  readonly kind: "result";
+} ? T_13 : never : never : never) extends (infer T_14) ? T_14 extends (MetadataOf<TLeft> extends (infer T_15) ? T_15 extends MetadataOf<TLeft> ? T_15 extends {
+  readonly kind: "result";
+} ? T_15 : never : never : never) ? T_14 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_16) ? T_16 extends MetadataOf<TLeft> ? T_16 extends {
+  readonly kind: "result";
+} ? T_16 : never : never : never) extends (infer T_17) ? T_17 extends (MetadataOf<TLeft> extends (infer T_18) ? T_18 extends MetadataOf<TLeft> ? T_18 extends {
+  readonly kind: "result";
+} ? T_18 : never : never : never) ? T_17 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_19) ? T_19 extends MetadataOf<TLeft> ? T_19 extends {
+  readonly kind: "result";
+} ? T_19 : never : never : never) extends (infer T_20) ? T_20 extends (MetadataOf<TLeft> extends (infer T_21) ? T_21 extends MetadataOf<TLeft> ? T_21 extends {
+  readonly kind: "result";
+} ? T_21 : never : never : never) ? T_20 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_22) ? T_22 extends MetadataOf<TLeft> ? T_22 extends {
+  readonly kind: "result";
+} ? T_22 : never : never : never) extends (infer T_23) ? T_23 extends (MetadataOf<TLeft> extends (infer T_24) ? T_24 extends MetadataOf<TLeft> ? T_24 extends {
+  readonly kind: "result";
+} ? T_24 : never : never : never) ? T_23 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>)>, (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_25) ? T_25 extends MetadataOf<TLeft> ? T_25 extends {
+  readonly kind: "result";
+} ? T_25 : never : never : never) extends (infer T_26) ? T_26 extends (MetadataOf<TLeft> extends (infer T_27) ? T_27 extends MetadataOf<TLeft> ? T_27 extends {
+  readonly kind: "result";
+} ? T_27 : never : never : never) ? T_26 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_28) ? T_28 extends MetadataOf<TLeft> ? T_28 extends {
+  readonly kind: "result";
+} ? T_28 : never : never : never) extends (infer T_29) ? T_29 extends (MetadataOf<TLeft> extends (infer T_30) ? T_30 extends MetadataOf<TLeft> ? T_30 extends {
+  readonly kind: "result";
+} ? T_30 : never : never : never) ? T_29 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_31) ? T_31 extends MetadataOf<TLeft> ? T_31 extends {
+  readonly kind: "result";
+} ? T_31 : never : never : never) extends (infer T_32) ? T_32 extends (MetadataOf<TLeft> extends (infer T_33) ? T_33 extends MetadataOf<TLeft> ? T_33 extends {
+  readonly kind: "result";
+} ? T_33 : never : never : never) ? T_32 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_34) ? T_34 extends MetadataOf<TLeft> ? T_34 extends {
+  readonly kind: "result";
+} ? T_34 : never : never : never) extends (infer T_35) ? T_35 extends (MetadataOf<TLeft> extends (infer T_36) ? T_36 extends MetadataOf<TLeft> ? T_36 extends {
+  readonly kind: "result";
+} ? T_36 : never : never : never) ? T_35 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> extends (infer T_37) ? T_37 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_38) ? T_38 extends MetadataOf<TLeft> ? T_38 extends {
+  readonly kind: "result";
+} ? T_38 : never : never : never) extends (infer T_39) ? T_39 extends (MetadataOf<TLeft> extends (infer T_40) ? T_40 extends MetadataOf<TLeft> ? T_40 extends {
+  readonly kind: "result";
+} ? T_40 : never : never : never) ? T_39 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_41) ? T_41 extends MetadataOf<TLeft> ? T_41 extends {
+  readonly kind: "result";
+} ? T_41 : never : never : never) extends (infer T_42) ? T_42 extends (MetadataOf<TLeft> extends (infer T_43) ? T_43 extends MetadataOf<TLeft> ? T_43 extends {
+  readonly kind: "result";
+} ? T_43 : never : never : never) ? T_42 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_44) ? T_44 extends MetadataOf<TLeft> ? T_44 extends {
+  readonly kind: "result";
+} ? T_44 : never : never : never) extends (infer T_45) ? T_45 extends (MetadataOf<TLeft> extends (infer T_46) ? T_46 extends MetadataOf<TLeft> ? T_46 extends {
+  readonly kind: "result";
+} ? T_46 : never : never : never) ? T_45 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_47) ? T_47 extends MetadataOf<TLeft> ? T_47 extends {
+  readonly kind: "result";
+} ? T_47 : never : never : never) extends (infer T_48) ? T_48 extends (MetadataOf<TLeft> extends (infer T_49) ? T_49 extends MetadataOf<TLeft> ? T_49 extends {
+  readonly kind: "result";
+} ? T_49 : never : never : never) ? T_48 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> ? T_37 extends {
+  readonly kind: "result";
+} ? T_37 : never : never : never) extends (infer T_50) ? T_50 extends (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_51) ? T_51 extends MetadataOf<TLeft> ? T_51 extends {
+  readonly kind: "result";
+} ? T_51 : never : never : never) extends (infer T_52) ? T_52 extends (MetadataOf<TLeft> extends (infer T_53) ? T_53 extends MetadataOf<TLeft> ? T_53 extends {
+  readonly kind: "result";
+} ? T_53 : never : never : never) ? T_52 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_54) ? T_54 extends MetadataOf<TLeft> ? T_54 extends {
+  readonly kind: "result";
+} ? T_54 : never : never : never) extends (infer T_55) ? T_55 extends (MetadataOf<TLeft> extends (infer T_56) ? T_56 extends MetadataOf<TLeft> ? T_56 extends {
+  readonly kind: "result";
+} ? T_56 : never : never : never) ? T_55 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_57) ? T_57 extends MetadataOf<TLeft> ? T_57 extends {
+  readonly kind: "result";
+} ? T_57 : never : never : never) extends (infer T_58) ? T_58 extends (MetadataOf<TLeft> extends (infer T_59) ? T_59 extends MetadataOf<TLeft> ? T_59 extends {
+  readonly kind: "result";
+} ? T_59 : never : never : never) ? T_58 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_60) ? T_60 extends MetadataOf<TLeft> ? T_60 extends {
+  readonly kind: "result";
+} ? T_60 : never : never : never) extends (infer T_61) ? T_61 extends (MetadataOf<TLeft> extends (infer T_62) ? T_62 extends MetadataOf<TLeft> ? T_62 extends {
+  readonly kind: "result";
+} ? T_62 : never : never : never) ? T_61 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> extends (infer T_63) ? T_63 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_64) ? T_64 extends MetadataOf<TLeft> ? T_64 extends {
+  readonly kind: "result";
+} ? T_64 : never : never : never) extends (infer T_65) ? T_65 extends (MetadataOf<TLeft> extends (infer T_66) ? T_66 extends MetadataOf<TLeft> ? T_66 extends {
+  readonly kind: "result";
+} ? T_66 : never : never : never) ? T_65 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_67) ? T_67 extends MetadataOf<TLeft> ? T_67 extends {
+  readonly kind: "result";
+} ? T_67 : never : never : never) extends (infer T_68) ? T_68 extends (MetadataOf<TLeft> extends (infer T_69) ? T_69 extends MetadataOf<TLeft> ? T_69 extends {
+  readonly kind: "result";
+} ? T_69 : never : never : never) ? T_68 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_70) ? T_70 extends MetadataOf<TLeft> ? T_70 extends {
+  readonly kind: "result";
+} ? T_70 : never : never : never) extends (infer T_71) ? T_71 extends (MetadataOf<TLeft> extends (infer T_72) ? T_72 extends MetadataOf<TLeft> ? T_72 extends {
+  readonly kind: "result";
+} ? T_72 : never : never : never) ? T_71 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_73) ? T_73 extends MetadataOf<TLeft> ? T_73 extends {
+  readonly kind: "result";
+} ? T_73 : never : never : never) extends (infer T_74) ? T_74 extends (MetadataOf<TLeft> extends (infer T_75) ? T_75 extends MetadataOf<TLeft> ? T_75 extends {
+  readonly kind: "result";
+} ? T_75 : never : never : never) ? T_74 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> ? T_63 extends {
+  readonly kind: "result";
+} ? T_63 : never : never : never) ? T_50 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>;
+declare const divide: <T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ArithmeticValidation<TLeft, R>, right: R) => ResultExpression<unknown, R | (TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+  readonly kind: "result";
+} ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) ? T_2 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_4) ? T_4 extends MetadataOf<TLeft> ? T_4 extends {
+  readonly kind: "result";
+} ? T_4 : never : never : never) extends (infer T_5) ? T_5 extends (MetadataOf<TLeft> extends (infer T_6) ? T_6 extends MetadataOf<TLeft> ? T_6 extends {
+  readonly kind: "result";
+} ? T_6 : never : never : never) ? T_5 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_7) ? T_7 extends MetadataOf<TLeft> ? T_7 extends {
+  readonly kind: "result";
+} ? T_7 : never : never : never) extends (infer T_8) ? T_8 extends (MetadataOf<TLeft> extends (infer T_9) ? T_9 extends MetadataOf<TLeft> ? T_9 extends {
+  readonly kind: "result";
+} ? T_9 : never : never : never) ? T_8 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_10) ? T_10 extends MetadataOf<TLeft> ? T_10 extends {
+  readonly kind: "result";
+} ? T_10 : never : never : never) extends (infer T_11) ? T_11 extends (MetadataOf<TLeft> extends (infer T_12) ? T_12 extends MetadataOf<TLeft> ? T_12 extends {
+  readonly kind: "result";
+} ? T_12 : never : never : never) ? T_11 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>), "operator", NullabilityOf<R | (TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_13) ? T_13 extends MetadataOf<TLeft> ? T_13 extends {
+  readonly kind: "result";
+} ? T_13 : never : never : never) extends (infer T_14) ? T_14 extends (MetadataOf<TLeft> extends (infer T_15) ? T_15 extends MetadataOf<TLeft> ? T_15 extends {
+  readonly kind: "result";
+} ? T_15 : never : never : never) ? T_14 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_16) ? T_16 extends MetadataOf<TLeft> ? T_16 extends {
+  readonly kind: "result";
+} ? T_16 : never : never : never) extends (infer T_17) ? T_17 extends (MetadataOf<TLeft> extends (infer T_18) ? T_18 extends MetadataOf<TLeft> ? T_18 extends {
+  readonly kind: "result";
+} ? T_18 : never : never : never) ? T_17 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_19) ? T_19 extends MetadataOf<TLeft> ? T_19 extends {
+  readonly kind: "result";
+} ? T_19 : never : never : never) extends (infer T_20) ? T_20 extends (MetadataOf<TLeft> extends (infer T_21) ? T_21 extends MetadataOf<TLeft> ? T_21 extends {
+  readonly kind: "result";
+} ? T_21 : never : never : never) ? T_20 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_22) ? T_22 extends MetadataOf<TLeft> ? T_22 extends {
+  readonly kind: "result";
+} ? T_22 : never : never : never) extends (infer T_23) ? T_23 extends (MetadataOf<TLeft> extends (infer T_24) ? T_24 extends MetadataOf<TLeft> ? T_24 extends {
+  readonly kind: "result";
+} ? T_24 : never : never : never) ? T_23 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>)>, (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_25) ? T_25 extends MetadataOf<TLeft> ? T_25 extends {
+  readonly kind: "result";
+} ? T_25 : never : never : never) extends (infer T_26) ? T_26 extends (MetadataOf<TLeft> extends (infer T_27) ? T_27 extends MetadataOf<TLeft> ? T_27 extends {
+  readonly kind: "result";
+} ? T_27 : never : never : never) ? T_26 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_28) ? T_28 extends MetadataOf<TLeft> ? T_28 extends {
+  readonly kind: "result";
+} ? T_28 : never : never : never) extends (infer T_29) ? T_29 extends (MetadataOf<TLeft> extends (infer T_30) ? T_30 extends MetadataOf<TLeft> ? T_30 extends {
+  readonly kind: "result";
+} ? T_30 : never : never : never) ? T_29 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_31) ? T_31 extends MetadataOf<TLeft> ? T_31 extends {
+  readonly kind: "result";
+} ? T_31 : never : never : never) extends (infer T_32) ? T_32 extends (MetadataOf<TLeft> extends (infer T_33) ? T_33 extends MetadataOf<TLeft> ? T_33 extends {
+  readonly kind: "result";
+} ? T_33 : never : never : never) ? T_32 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_34) ? T_34 extends MetadataOf<TLeft> ? T_34 extends {
+  readonly kind: "result";
+} ? T_34 : never : never : never) extends (infer T_35) ? T_35 extends (MetadataOf<TLeft> extends (infer T_36) ? T_36 extends MetadataOf<TLeft> ? T_36 extends {
+  readonly kind: "result";
+} ? T_36 : never : never : never) ? T_35 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> extends (infer T_37) ? T_37 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_38) ? T_38 extends MetadataOf<TLeft> ? T_38 extends {
+  readonly kind: "result";
+} ? T_38 : never : never : never) extends (infer T_39) ? T_39 extends (MetadataOf<TLeft> extends (infer T_40) ? T_40 extends MetadataOf<TLeft> ? T_40 extends {
+  readonly kind: "result";
+} ? T_40 : never : never : never) ? T_39 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_41) ? T_41 extends MetadataOf<TLeft> ? T_41 extends {
+  readonly kind: "result";
+} ? T_41 : never : never : never) extends (infer T_42) ? T_42 extends (MetadataOf<TLeft> extends (infer T_43) ? T_43 extends MetadataOf<TLeft> ? T_43 extends {
+  readonly kind: "result";
+} ? T_43 : never : never : never) ? T_42 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_44) ? T_44 extends MetadataOf<TLeft> ? T_44 extends {
+  readonly kind: "result";
+} ? T_44 : never : never : never) extends (infer T_45) ? T_45 extends (MetadataOf<TLeft> extends (infer T_46) ? T_46 extends MetadataOf<TLeft> ? T_46 extends {
+  readonly kind: "result";
+} ? T_46 : never : never : never) ? T_45 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_47) ? T_47 extends MetadataOf<TLeft> ? T_47 extends {
+  readonly kind: "result";
+} ? T_47 : never : never : never) extends (infer T_48) ? T_48 extends (MetadataOf<TLeft> extends (infer T_49) ? T_49 extends MetadataOf<TLeft> ? T_49 extends {
+  readonly kind: "result";
+} ? T_49 : never : never : never) ? T_48 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> ? T_37 extends {
+  readonly kind: "result";
+} ? T_37 : never : never : never) extends (infer T_50) ? T_50 extends (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_51) ? T_51 extends MetadataOf<TLeft> ? T_51 extends {
+  readonly kind: "result";
+} ? T_51 : never : never : never) extends (infer T_52) ? T_52 extends (MetadataOf<TLeft> extends (infer T_53) ? T_53 extends MetadataOf<TLeft> ? T_53 extends {
+  readonly kind: "result";
+} ? T_53 : never : never : never) ? T_52 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_54) ? T_54 extends MetadataOf<TLeft> ? T_54 extends {
+  readonly kind: "result";
+} ? T_54 : never : never : never) extends (infer T_55) ? T_55 extends (MetadataOf<TLeft> extends (infer T_56) ? T_56 extends MetadataOf<TLeft> ? T_56 extends {
+  readonly kind: "result";
+} ? T_56 : never : never : never) ? T_55 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_57) ? T_57 extends MetadataOf<TLeft> ? T_57 extends {
+  readonly kind: "result";
+} ? T_57 : never : never : never) extends (infer T_58) ? T_58 extends (MetadataOf<TLeft> extends (infer T_59) ? T_59 extends MetadataOf<TLeft> ? T_59 extends {
+  readonly kind: "result";
+} ? T_59 : never : never : never) ? T_58 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_60) ? T_60 extends MetadataOf<TLeft> ? T_60 extends {
+  readonly kind: "result";
+} ? T_60 : never : never : never) extends (infer T_61) ? T_61 extends (MetadataOf<TLeft> extends (infer T_62) ? T_62 extends MetadataOf<TLeft> ? T_62 extends {
+  readonly kind: "result";
+} ? T_62 : never : never : never) ? T_61 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> extends (infer T_63) ? T_63 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_64) ? T_64 extends MetadataOf<TLeft> ? T_64 extends {
+  readonly kind: "result";
+} ? T_64 : never : never : never) extends (infer T_65) ? T_65 extends (MetadataOf<TLeft> extends (infer T_66) ? T_66 extends MetadataOf<TLeft> ? T_66 extends {
+  readonly kind: "result";
+} ? T_66 : never : never : never) ? T_65 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_67) ? T_67 extends MetadataOf<TLeft> ? T_67 extends {
+  readonly kind: "result";
+} ? T_67 : never : never : never) extends (infer T_68) ? T_68 extends (MetadataOf<TLeft> extends (infer T_69) ? T_69 extends MetadataOf<TLeft> ? T_69 extends {
+  readonly kind: "result";
+} ? T_69 : never : never : never) ? T_68 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_70) ? T_70 extends MetadataOf<TLeft> ? T_70 extends {
+  readonly kind: "result";
+} ? T_70 : never : never : never) extends (infer T_71) ? T_71 extends (MetadataOf<TLeft> extends (infer T_72) ? T_72 extends MetadataOf<TLeft> ? T_72 extends {
+  readonly kind: "result";
+} ? T_72 : never : never : never) ? T_71 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_73) ? T_73 extends MetadataOf<TLeft> ? T_73 extends {
+  readonly kind: "result";
+} ? T_73 : never : never : never) extends (infer T_74) ? T_74 extends (MetadataOf<TLeft> extends (infer T_75) ? T_75 extends MetadataOf<TLeft> ? T_75 extends {
+  readonly kind: "result";
+} ? T_75 : never : never : never) ? T_74 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> ? T_63 extends {
+  readonly kind: "result";
+} ? T_63 : never : never : never) ? T_50 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>;
+declare const modulo: <T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ArithmeticValidation<TLeft, R>, right: R) => ResultExpression<unknown, R | (TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+  readonly kind: "result";
+} ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) ? T_2 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_4) ? T_4 extends MetadataOf<TLeft> ? T_4 extends {
+  readonly kind: "result";
+} ? T_4 : never : never : never) extends (infer T_5) ? T_5 extends (MetadataOf<TLeft> extends (infer T_6) ? T_6 extends MetadataOf<TLeft> ? T_6 extends {
+  readonly kind: "result";
+} ? T_6 : never : never : never) ? T_5 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_7) ? T_7 extends MetadataOf<TLeft> ? T_7 extends {
+  readonly kind: "result";
+} ? T_7 : never : never : never) extends (infer T_8) ? T_8 extends (MetadataOf<TLeft> extends (infer T_9) ? T_9 extends MetadataOf<TLeft> ? T_9 extends {
+  readonly kind: "result";
+} ? T_9 : never : never : never) ? T_8 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_10) ? T_10 extends MetadataOf<TLeft> ? T_10 extends {
+  readonly kind: "result";
+} ? T_10 : never : never : never) extends (infer T_11) ? T_11 extends (MetadataOf<TLeft> extends (infer T_12) ? T_12 extends MetadataOf<TLeft> ? T_12 extends {
+  readonly kind: "result";
+} ? T_12 : never : never : never) ? T_11 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>), "operator", NullabilityOf<R | (TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_13) ? T_13 extends MetadataOf<TLeft> ? T_13 extends {
+  readonly kind: "result";
+} ? T_13 : never : never : never) extends (infer T_14) ? T_14 extends (MetadataOf<TLeft> extends (infer T_15) ? T_15 extends MetadataOf<TLeft> ? T_15 extends {
+  readonly kind: "result";
+} ? T_15 : never : never : never) ? T_14 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_16) ? T_16 extends MetadataOf<TLeft> ? T_16 extends {
+  readonly kind: "result";
+} ? T_16 : never : never : never) extends (infer T_17) ? T_17 extends (MetadataOf<TLeft> extends (infer T_18) ? T_18 extends MetadataOf<TLeft> ? T_18 extends {
+  readonly kind: "result";
+} ? T_18 : never : never : never) ? T_17 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_19) ? T_19 extends MetadataOf<TLeft> ? T_19 extends {
+  readonly kind: "result";
+} ? T_19 : never : never : never) extends (infer T_20) ? T_20 extends (MetadataOf<TLeft> extends (infer T_21) ? T_21 extends MetadataOf<TLeft> ? T_21 extends {
+  readonly kind: "result";
+} ? T_21 : never : never : never) ? T_20 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_22) ? T_22 extends MetadataOf<TLeft> ? T_22 extends {
+  readonly kind: "result";
+} ? T_22 : never : never : never) extends (infer T_23) ? T_23 extends (MetadataOf<TLeft> extends (infer T_24) ? T_24 extends MetadataOf<TLeft> ? T_24 extends {
+  readonly kind: "result";
+} ? T_24 : never : never : never) ? T_23 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>)>, (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_25) ? T_25 extends MetadataOf<TLeft> ? T_25 extends {
+  readonly kind: "result";
+} ? T_25 : never : never : never) extends (infer T_26) ? T_26 extends (MetadataOf<TLeft> extends (infer T_27) ? T_27 extends MetadataOf<TLeft> ? T_27 extends {
+  readonly kind: "result";
+} ? T_27 : never : never : never) ? T_26 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_28) ? T_28 extends MetadataOf<TLeft> ? T_28 extends {
+  readonly kind: "result";
+} ? T_28 : never : never : never) extends (infer T_29) ? T_29 extends (MetadataOf<TLeft> extends (infer T_30) ? T_30 extends MetadataOf<TLeft> ? T_30 extends {
+  readonly kind: "result";
+} ? T_30 : never : never : never) ? T_29 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_31) ? T_31 extends MetadataOf<TLeft> ? T_31 extends {
+  readonly kind: "result";
+} ? T_31 : never : never : never) extends (infer T_32) ? T_32 extends (MetadataOf<TLeft> extends (infer T_33) ? T_33 extends MetadataOf<TLeft> ? T_33 extends {
+  readonly kind: "result";
+} ? T_33 : never : never : never) ? T_32 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_34) ? T_34 extends MetadataOf<TLeft> ? T_34 extends {
+  readonly kind: "result";
+} ? T_34 : never : never : never) extends (infer T_35) ? T_35 extends (MetadataOf<TLeft> extends (infer T_36) ? T_36 extends MetadataOf<TLeft> ? T_36 extends {
+  readonly kind: "result";
+} ? T_36 : never : never : never) ? T_35 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> extends (infer T_37) ? T_37 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_38) ? T_38 extends MetadataOf<TLeft> ? T_38 extends {
+  readonly kind: "result";
+} ? T_38 : never : never : never) extends (infer T_39) ? T_39 extends (MetadataOf<TLeft> extends (infer T_40) ? T_40 extends MetadataOf<TLeft> ? T_40 extends {
+  readonly kind: "result";
+} ? T_40 : never : never : never) ? T_39 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_41) ? T_41 extends MetadataOf<TLeft> ? T_41 extends {
+  readonly kind: "result";
+} ? T_41 : never : never : never) extends (infer T_42) ? T_42 extends (MetadataOf<TLeft> extends (infer T_43) ? T_43 extends MetadataOf<TLeft> ? T_43 extends {
+  readonly kind: "result";
+} ? T_43 : never : never : never) ? T_42 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_44) ? T_44 extends MetadataOf<TLeft> ? T_44 extends {
+  readonly kind: "result";
+} ? T_44 : never : never : never) extends (infer T_45) ? T_45 extends (MetadataOf<TLeft> extends (infer T_46) ? T_46 extends MetadataOf<TLeft> ? T_46 extends {
+  readonly kind: "result";
+} ? T_46 : never : never : never) ? T_45 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_47) ? T_47 extends MetadataOf<TLeft> ? T_47 extends {
+  readonly kind: "result";
+} ? T_47 : never : never : never) extends (infer T_48) ? T_48 extends (MetadataOf<TLeft> extends (infer T_49) ? T_49 extends MetadataOf<TLeft> ? T_49 extends {
+  readonly kind: "result";
+} ? T_49 : never : never : never) ? T_48 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> ? T_37 extends {
+  readonly kind: "result";
+} ? T_37 : never : never : never) extends (infer T_50) ? T_50 extends (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_51) ? T_51 extends MetadataOf<TLeft> ? T_51 extends {
+  readonly kind: "result";
+} ? T_51 : never : never : never) extends (infer T_52) ? T_52 extends (MetadataOf<TLeft> extends (infer T_53) ? T_53 extends MetadataOf<TLeft> ? T_53 extends {
+  readonly kind: "result";
+} ? T_53 : never : never : never) ? T_52 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_54) ? T_54 extends MetadataOf<TLeft> ? T_54 extends {
+  readonly kind: "result";
+} ? T_54 : never : never : never) extends (infer T_55) ? T_55 extends (MetadataOf<TLeft> extends (infer T_56) ? T_56 extends MetadataOf<TLeft> ? T_56 extends {
+  readonly kind: "result";
+} ? T_56 : never : never : never) ? T_55 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_57) ? T_57 extends MetadataOf<TLeft> ? T_57 extends {
+  readonly kind: "result";
+} ? T_57 : never : never : never) extends (infer T_58) ? T_58 extends (MetadataOf<TLeft> extends (infer T_59) ? T_59 extends MetadataOf<TLeft> ? T_59 extends {
+  readonly kind: "result";
+} ? T_59 : never : never : never) ? T_58 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_60) ? T_60 extends MetadataOf<TLeft> ? T_60 extends {
+  readonly kind: "result";
+} ? T_60 : never : never : never) extends (infer T_61) ? T_61 extends (MetadataOf<TLeft> extends (infer T_62) ? T_62 extends MetadataOf<TLeft> ? T_62 extends {
+  readonly kind: "result";
+} ? T_62 : never : never : never) ? T_61 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> extends (infer T_63) ? T_63 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_64) ? T_64 extends MetadataOf<TLeft> ? T_64 extends {
+  readonly kind: "result";
+} ? T_64 : never : never : never) extends (infer T_65) ? T_65 extends (MetadataOf<TLeft> extends (infer T_66) ? T_66 extends MetadataOf<TLeft> ? T_66 extends {
+  readonly kind: "result";
+} ? T_66 : never : never : never) ? T_65 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlNumericLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_67) ? T_67 extends MetadataOf<TLeft> ? T_67 extends {
+  readonly kind: "result";
+} ? T_67 : never : never : never) extends (infer T_68) ? T_68 extends (MetadataOf<TLeft> extends (infer T_69) ? T_69 extends MetadataOf<TLeft> ? T_69 extends {
+  readonly kind: "result";
+} ? T_69 : never : never : never) ? T_68 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlNumericLike> & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T_70) ? T_70 extends MetadataOf<TLeft> ? T_70 extends {
+  readonly kind: "result";
+} ? T_70 : never : never : never) extends (infer T_71) ? T_71 extends (MetadataOf<TLeft> extends (infer T_72) ? T_72 extends MetadataOf<TLeft> ? T_72 extends {
+  readonly kind: "result";
+} ? T_72 : never : never : never) ? T_71 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_73) ? T_73 extends MetadataOf<TLeft> ? T_73 extends {
+  readonly kind: "result";
+} ? T_73 : never : never : never) extends (infer T_74) ? T_74 extends (MetadataOf<TLeft> extends (infer T_75) ? T_75 extends MetadataOf<TLeft> ? T_75 extends {
+  readonly kind: "result";
+} ? T_75 : never : never : never) ? T_74 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>>> ? T_63 extends {
+  readonly kind: "result";
+} ? T_63 : never : never : never) ? T_50 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>;
+//#endregion
+//#region src/query/clauses/types.d.ts
+type ClausePlacement = 'before-select' | 'after-select';
+interface SelectClause<TMetadata = any> extends Fragment<TMetadata> {
+  readonly clauseKind: string;
+  readonly placement: ClausePlacement;
+  readonly order: number;
+}
+type AnySelectClause = SelectClause<any>;
+//#endregion
+//#region src/query/clauses/distinct.d.ts
+interface DistinctClause extends SelectClause<never> {
+  readonly clauseKind: 'distinct';
+}
+declare function distinct(): DistinctClause;
+//#endregion
+//#region src/query/clauses/having.d.ts
+interface HavingClause<TMetadata = never> extends SelectClause<TMetadata> {
+  readonly clauseKind: 'having';
+  readonly condition: BooleanExpression<any>;
+}
+type HavingComposition<TCondition extends BooleanExpression<any> | Omit$1> = TCondition extends Omit$1 ? Omit$1 : TCondition extends BooleanExpression<any> ? HavingClause<InheritedMetadata<TCondition>> : never;
+type HavingValidation<TCondition> = TCondition extends Omit$1 ? unknown : SqlCapabilityValidation<ExpressionSqlType<TCondition>, SqlBoolean>;
+declare function having<TCondition extends BooleanExpression<any> | Omit$1>(condition: TCondition & HavingValidation<TCondition>): HavingComposition<TCondition>;
+//#endregion
+//#region src/query/clauses/pagination.d.ts
+interface OffsetClause extends SelectClause<never> {
+  readonly clauseKind: 'offset';
+  readonly rows: number;
+}
+type AnyPaginationClause = OffsetClause | FetchClause;
+declare function offset(rows: number): OffsetClause;
+interface FetchClause<TRows extends number = number> extends SelectClause<never> {
+  readonly clauseKind: 'fetch';
+  readonly direction: 'FIRST' | 'NEXT';
+  readonly rows: TRows;
+}
+declare function fetchFirst<const TRows extends number>(rows: TRows): FetchClause<TRows>;
+declare function fetchNext<const TRows extends number>(rows: TRows): FetchClause<TRows>;
+//#endregion
+//#region src/query/clauses/row-lock.d.ts
+interface RowLockOptions<TMode extends RowLockMode = RowLockMode, TWait extends RowLockWaitPolicy = RowLockWaitPolicy> {
+  readonly mode?: TMode;
+  readonly wait?: TWait;
+  readonly waitPolicy?: TWait;
+}
+interface RowLockClause<TMode extends RowLockMode = RowLockMode, TWait extends RowLockWaitPolicy = RowLockWaitPolicy> extends SelectClause<RequiresCapabilityMeta<'row-locking'>> {
+  readonly clauseKind: 'row-lock';
+  readonly mode: TMode;
+  readonly wait: TWait;
+}
+declare function rowLock(): RowLockClause<'update', 'default'>;
+declare function rowLock<TMode extends RowLockMode>(mode: TMode): RowLockClause<TMode, 'default'>;
+declare function rowLock<TMode extends RowLockMode, TWait extends RowLockWaitPolicy>(mode: TMode, wait: TWait): RowLockClause<TMode, TWait>;
+declare function rowLock(options: RowLockOptions): RowLockClause;
+//#endregion
+//#region src/query/clauses/where.d.ts
+interface WhereClause<TMetadata = never> extends SelectClause<TMetadata> {
+  readonly clauseKind: 'where';
+  readonly condition: BooleanExpression<any>;
+}
+type WhereComposition<TCondition extends BooleanExpression<any> | Omit$1> = TCondition extends Omit$1 ? Omit$1 : TCondition extends BooleanExpression<any> ? WhereClause<InheritedMetadata<TCondition>> : never;
+type WhereValidation<TCondition> = TCondition extends Omit$1 ? unknown : SqlCapabilityValidation<ExpressionSqlType<TCondition>, SqlBoolean>;
+declare function where<TCondition extends BooleanExpression<any> | Omit$1>(condition: TCondition & WhereValidation<TCondition>): WhereComposition<TCondition>;
+//#endregion
+//#region src/query/omit.d.ts
+/** An explicit placeholder for a safely omitted SELECT clause or projection field. */
+declare const omit: unique symbol;
+type Omit$1 = typeof omit;
+type OmittableSelectClause = DistinctClause | HavingClause<any> | OrderByClause<any> | OffsetClause | FetchClause | RowLockClause | WhereClause<any>;
+type SelectPart = AnySelectClause | Omit$1;
+type PresentClauses<TParts extends readonly SelectPart[]> = { readonly [TIndex in keyof TParts]: Exclude<TParts[TIndex], Omit$1>; };
+type InvalidOmittedClauses<TParts extends readonly SelectPart[]> = { [TIndex in keyof TParts]: Omit$1 extends TParts[TIndex] ? Exclude<TParts[TIndex], Omit$1> extends OmittableSelectClause ? never : Exclude<TParts[TIndex], Omit$1> : never; }[number];
+type OmissionValidation<TParts extends readonly SelectPart[]> = [InvalidOmittedClauses<TParts>] extends [never] ? unknown : QueryTypeValidation<'invalid-omission', 'select.omit', 'Use omit only for a conditional SELECT clause or projection field.', InvalidOmittedClauses<TParts>>;
+//#endregion
+//#region src/expressions/operators/logic.d.ts
+type BooleanOperand = BooleanExpression<any> | Omit$1;
+type PresentConditions<TConditions extends readonly BooleanOperand[]> = Exclude<TConditions[number], Omit$1>;
+type BooleanComposition<TConditions extends readonly BooleanOperand[]> = [PresentConditions<TConditions>] extends [never] ? Omit$1 : ResultExpression<boolean, PresentConditions<TConditions>, 'operator', NullabilityOf<PresentConditions<TConditions>>, SqlBoolean> | (Omit$1 extends TConditions[number] ? Omit$1 : never);
+type BooleanConditionsValidation<TConditions extends readonly unknown[]> = TConditions extends readonly [infer THead, ...infer TTail] ? (THead extends Omit$1 ? unknown : SqlCapabilityValidation<ExpressionSqlType<THead>, SqlBoolean>) & BooleanConditionsValidation<TTail> : unknown;
+declare function and<const TConditions extends readonly BooleanOperand[]>(...conditions: TConditions & BooleanConditionsValidation<TConditions>): BooleanComposition<TConditions>;
+declare function or<const TConditions extends readonly BooleanOperand[]>(...conditions: TConditions & BooleanConditionsValidation<TConditions>): BooleanComposition<TConditions>;
+declare function not<TCondition extends BooleanExpression<any>>(condition: TCondition & SqlCapabilityValidation<ExpressionSqlType<TCondition>, SqlBoolean>): ResultExpression<boolean, TCondition, "operator", NullabilityOf<TCondition>, SqlBoolean>;
+//#endregion
+//#region src/schema/alias.d.ts
+type SourceIndexes$1<T> = T extends {
+  readonly indexes: infer TIndexes extends SourceIndexesRecord;
+} ? TIndexes : {};
+type AliasIdentity<TBase, TAlias extends string> = {
+  readonly sourceKind: 'alias';
+  readonly alias: TAlias;
+  readonly base: TBase;
+};
+type AliasedSource<TBase extends Source<any, any, any, any, any>, TAlias extends string> = Source<AliasIdentity<SourceIdentity<TBase>, TAlias>, SourceRow<TBase>, RequiresOuterMetadataOf<TBase> | CapabilityMetadataOf<TBase>, SourceSqlTypeMap<TBase>, SourceConstraints<TBase>> & {
+  readonly alias: TAlias;
+  readonly base: TBase;
+  readonly columns: SourceColumns<SourceRow<TBase>, AliasIdentity<SourceIdentity<TBase>, TAlias>, SourceSqlTypeMap<TBase>>;
+  readonly constraints: SourceConstraints<TBase>;
+  readonly indexes: SourceIndexes$1<TBase>;
+} & SourceColumns<SourceRow<TBase>, AliasIdentity<SourceIdentity<TBase>, TAlias>, SourceSqlTypeMap<TBase>>;
+type QueryAliasIdentity<TAlias extends string> = {
+  readonly sourceKind: 'query-alias';
+  readonly alias: TAlias;
+};
+type QuerySource<TRow extends object, TAlias extends string, TMetadata = never, TSqlTypes extends SourceSqlTypes<TRow> = UnknownSourceSqlTypes<TRow>> = Source<QueryAliasIdentity<TAlias>, TRow, TMetadata, TSqlTypes> & {
+  readonly alias: TAlias;
+  readonly query: Query<TRow, any, TMetadata, TSqlTypes>;
+  readonly columns: SourceColumns<TRow, QueryAliasIdentity<TAlias>, TSqlTypes>;
+} & SourceColumns<TRow, QueryAliasIdentity<TAlias>, TSqlTypes>;
+declare function alias<TBase extends Source<any, any, any, any, any>, const TAlias extends string>(source: TBase, name: TAlias): AliasedSource<TBase, TAlias>;
+declare function alias<TQuery extends AnyQuery, const TAlias extends string>(query: TQuery, name: TAlias): QuerySource<QueryRow<TQuery>, TAlias, RequiresOuterMetadataOf<TQuery> | CapabilityMetadataOf<TQuery>, QuerySqlTypeMap<TQuery>>;
+type LateralIdentity<TAlias extends string> = {
+  readonly sourceKind: 'lateral';
+  readonly alias: TAlias;
+};
+type LateralSource<TQuery extends AnyQuery, TAlias extends string> = Source<LateralIdentity<TAlias>, QueryRow<TQuery>, RequiresOuterMetadataOf<TQuery> | CapabilityMetadataOf<TQuery>, QuerySqlTypeMap<TQuery>> & {
+  readonly alias: TAlias;
+  readonly query: TQuery;
+  readonly columns: SourceColumns<QueryRow<TQuery>, LateralIdentity<TAlias>, QuerySqlTypeMap<TQuery>>;
+} & SourceColumns<QueryRow<TQuery>, LateralIdentity<TAlias>, QuerySqlTypeMap<TQuery>>;
+/** Render a query as a LATERAL source whose outer requirements stay visible. */
+declare function lateral<TQuery extends AnyQuery, const TAlias extends string>(query: TQuery, name: TAlias): LateralSource<TQuery, TAlias>;
+//#endregion
+//#region src/schema/registry.d.ts
+/** The first naming-policy version used by schema metadata. */
+declare const schemaNamingPolicyVersion: 1;
+/** A deterministic policy for names generated from logical schema IDs. */
+interface SchemaNamingPolicy {
+  /** Versioned policy identifier stored with schema metadata. */
+  readonly version: typeof schemaNamingPolicyVersion;
+  /** Generate a physical table name from a logical table ID. */
+  readonly tableName: (logicalId: string) => string;
+}
+/**
+ * The built-in naming policy for schema-generated physical names.
+ *
+ * Explicit names supplied to `table()` remain unchanged. The policy is used
+ * by tooling when it needs a physical name for a logical table ID.
+ */
+declare const defaultSchemaNamingPolicy: SchemaNamingPolicy;
+/** A table record accepted by {@link schema}. */
+type SchemaTableRecord = Readonly<Record<string, AnyTable>>;
+/** A tuple form that can represent duplicate IDs for diagnostic testing. */
+type SchemaTableInput = readonly [string, AnyTable];
+/** Options that apply to a root schema registry. */
+interface SchemaOptions {
+  /** Physical database namespace used by the schema, such as `public`. */
+  readonly namespace?: string;
+  /** Naming policy metadata used by snapshot tooling for generated names. */
+  readonly namingPolicy?: SchemaNamingPolicy;
+}
+/** A physical-name record for one stable registry entry. */
+interface SchemaTableEntry<TId extends string = string, TTable extends AnyTable = AnyTable> {
+  /** Stable logical ID taken from the schema registry key. */
+  readonly id: TId;
+  /** The query-facing table declaration retained by the registry. */
+  readonly table: TTable;
+  /** Physical SQL name used by the table declaration. */
+  readonly physicalName: string;
+}
+type SchemaTableRegistry<TTables extends SchemaTableRecord> = { readonly [K in keyof TTables & string]: SchemaTableEntry<K, TTables[K]>; };
+type SchemaTableNames<TTables extends SchemaTableRecord> = Readonly<{ [K in keyof TTables & string]: string; }>;
+/** The root model returned by {@link schema}. */
+interface Schema<TTables extends SchemaTableRecord = SchemaTableRecord> {
+  readonly schemaKind: 'schema';
+  /** Tables keyed by stable logical ID. */
+  readonly tables: Readonly<TTables>;
+  /** Explicit registry entries with logical and physical identity separated. */
+  readonly registry: SchemaTableRegistry<TTables>;
+  /** Materialized physical names keyed by stable logical ID. */
+  readonly tableNames: SchemaTableNames<TTables>;
+  /** Optional database namespace. */
+  readonly namespace: string | undefined;
+  /** Versioned naming policy used by schema tooling. */
+  readonly namingPolicy: SchemaNamingPolicy;
+}
+/** A structured validation finding produced while constructing a schema. */
+interface SchemaDiagnostic {
+  readonly code: 'invalid-table-id' | 'duplicate-table-id' | 'duplicate-physical-name' | 'invalid-namespace' | 'generated-name-collision';
+  readonly message: string;
+  /** Location of the invalid or conflicting declaration. */
+  readonly path: readonly (string | number)[];
+  /** Other declaration locations involved in a collision, when applicable. */
+  readonly relatedPaths?: readonly (readonly (string | number)[])[];
+}
+/** Error thrown when a root schema fails registry or naming validation. */
+declare class SchemaValidationError extends Error {
+  readonly name = "SchemaValidationError";
+  readonly diagnostics: readonly SchemaDiagnostic[];
+  /** Alias matching validation libraries that call findings "issues". */
+  readonly issues: readonly SchemaDiagnostic[];
+  constructor(diagnostics: readonly SchemaDiagnostic[]);
+}
+type EntriesToTables<TEntries extends readonly SchemaTableInput[]> = { readonly [TEntry in TEntries[number] as TEntry[0]]: Extract<TEntries[number], readonly [TEntry[0], AnyTable]>[1]; };
+/**
+ * Create an immutable root registry keyed by stable logical table IDs.
+ *
+ * The input keys are logical IDs. Each table keeps the physical name already
+ * used by query rendering, so registering a table does not change its row
+ * inference, source identity, or generated SQL. The optional namespace is
+ * metadata for schema tooling and is not added to ordinary query rendering.
+ *
+ * @throws {@link SchemaValidationError} when IDs, physical names, namespaces,
+ * or generated names collide or are invalid.
+ */
+declare function schema<const TTables extends SchemaTableRecord>(tables: TTables, options?: SchemaOptions): Schema<TTables>;
+/**
+ * Tuple input is useful for integrations that need duplicate-ID diagnostics
+ * before converting declarations into an object record.
+ */
+declare function schema<const TEntries extends readonly SchemaTableInput[]>(tables: TEntries, options?: SchemaOptions): Schema<EntriesToTables<TEntries>>;
+/** Generate a v1 physical name for a logical table ID. */
+declare function generatedTableName(logicalId: string, namingPolicy?: SchemaNamingPolicy): string;
+//#endregion
+//#region src/schema/expressions.d.ts
+/** SQL declaration context in which a schema expression will be emitted. */
+type SchemaExpressionMode = 'default' | 'generated' | 'check' | 'index';
+/** Stable error categories for schema-expression validation failures. */
+type SchemaExpressionErrorCode = 'not-deterministic' | 'unsupported-expression' | 'parameter' | 'unsupported-value' | 'column-not-allowed' | 'dialect-mismatch' | 'invalid-literal';
+/** Error raised before a schema expression can become persisted SQL. */
+declare class SchemaExpressionError extends TypeError {
+  readonly code: SchemaExpressionErrorCode;
+  readonly mode?: SchemaExpressionMode;
+  constructor(code: SchemaExpressionErrorCode, message: string, mode?: SchemaExpressionMode);
+}
+/**
+ * Restricted rendering surface made available to explicit schema extensions.
+ * `parameter()` is retained for structural compatibility with query
+ * renderers, but always throws; use `literal()` for deterministic values.
+ */
+interface SchemaRenderContext extends RenderContext {
+  readonly schemaMode: SchemaExpressionMode;
+  literal(value: unknown): void;
+  readonly renderColumnReference: (columnName: string) => void;
+}
+/** Result of schema rendering. The parameter list is always empty. */
+interface RenderedSchemaExpression {
+  readonly text: string;
+  readonly parameters: readonly [];
+}
+/** Options for rendering a branded schema expression. */
+interface SchemaRenderOptions {
+  readonly mode: SchemaExpressionMode;
+  readonly dialect?: Dialect;
+}
+/** Compile-time gate used by schema renderers to reject ordinary query ASTs. */
+type SchemaExpressionInput<TExpression extends AnyExpression> = TExpression extends AnySchemaExpression ? TExpression : TExpression & {
+  readonly __requires_deterministic_schema_expression__: never;
+};
+/** A dialect-tagged raw SQL expression for syntax Qubu does not model. */
+interface UnsafeSchemaSqlExpression extends SchemaExpression<never, 'unsafe'> {
+  readonly schemaSqlDialect: string;
+  readonly schemaSql: string;
+}
+/**
+ * Normalize only line endings. Whitespace, quoting, and every other byte of
+ * a raw schema expression remain under the extension author's control.
+ */
+declare function normalizeSchemaSql(sql: string): string;
+/**
+ * Explicitly opt an audited expression into deterministic schema rendering.
+ * The wrapper does not rewrite the renderer; it records the author's promise
+ * so schema consumers can reject ordinary query extensions by default.
+ */
+declare function schemaExpression<TExpression extends AnyExpression>(expression: TExpression): SchemaExpression<MetadataOf<TExpression>, TExpression['expressionKind']>;
+/**
+ * Define an extension with the restricted schema context. This is the typed
+ * alternative to {@link unsafeSchemaSql} for deterministic custom syntax.
+ */
+declare function defineSchemaExpression<TMetadata = never, TKind extends ExpressionKind = 'function'>(kind: TKind, render: (context: SchemaRenderContext) => void): SchemaExpression<TMetadata, TKind>;
+/**
+ * Create a dialect-specific raw schema expression. The SQL is parameter-free
+ * by contract and is preserved exactly apart from CRLF/CR line-ending
+ * normalization.
+ */
+declare function unsafeSchemaSql(dialect: string, sql: string): UnsafeSchemaSqlExpression;
+declare function unsafeSchemaSql(options: {
+  readonly dialect: string;
+  readonly sql: string;
+}): UnsafeSchemaSqlExpression;
+/** Identify a dialect-tagged raw schema expression. */
+declare function isUnsafeSchemaSql(value: unknown): value is UnsafeSchemaSqlExpression;
+/** Render a schema expression without ever creating query parameters. */
+declare function renderSchemaExpression<TExpression extends AnyExpression>(expression: SchemaExpressionInput<TExpression>, options: SchemaRenderOptions): RenderedSchemaExpression;
+declare function renderSchemaExpression<TExpression extends AnyExpression>(expression: SchemaExpressionInput<TExpression>, mode: SchemaExpressionMode, dialect?: Dialect): RenderedSchemaExpression;
+/** Convenience form for callers that only need the SQL text. */
+declare function renderSchemaSql<TExpression extends AnyExpression>(expression: SchemaExpressionInput<TExpression>, options: SchemaRenderOptions): string;
+//#endregion
+//#region src/schema/dialect.d.ts
+/**
+ * Schema-only behavior layered onto a query dialect.
+ *
+ * The query policy is deliberately not repeated here: identifier quoting,
+ * placeholders, JSON, casts, and capability identity all come from the
+ * enclosing {@link SchemaDialect}.
+ */
+interface SchemaDialectHooks {
+  /** Version of this dialect's schema metadata extension contract. */
+  readonly version: number;
+  /** Optional executable naming policy retained by snapshot metadata. */
+  readonly namingPolicy?: SnapshotNamingPolicy;
+  /** Validate engine-specific schema facts before common traversal. */
+  readonly validate?: (schema: Schema<any>, context: SnapshotValidationContext) => readonly SnapshotDiagnostic[];
+  /** Encode portable or native physical column storage. */
+  readonly encodeStorage?: (storage: ColumnStorage, context: SnapshotStorageContext) => SnapshotStorage;
+  /** Encode a deterministic expression for its declaration context. */
+  readonly encodeExpression?: (expression: AnyExpression, context: SnapshotExpressionContext) => SnapshotExpression;
+  /** Encode dialect-owned constraint, index, and identity metadata. */
+  readonly encodeDialectExtension?: (extension: SchemaDialectExtension, context: SnapshotExtensionContext) => SnapshotDialectExtension;
+}
+/**
+ * A schema dialect is a strict capability superset of a query dialect.
+ *
+ * A schema dialect must be created with {@link createSchemaDialect}; that
+ * helper preserves the exact query rendering object and adds only schema
+ * behavior and snapshot metadata.
+ */
+interface SchemaDialect<TCapabilities extends DialectCapability = DialectCapability> extends Dialect<TCapabilities> {
+  readonly schema: SchemaDialectHooks;
+}
+/**
+ * Add schema behavior to an existing query dialect without rebuilding any of
+ * its identifier, literal, placeholder, JSON, cast, or capability policies.
+ */
+declare function createSchemaDialect<const TCapabilities extends DialectCapability = DialectCapability>(queryDialect: Dialect<TCapabilities>, schema: SchemaDialectHooks): SchemaDialect<TCapabilities>;
+//#endregion
+//#region src/query/selection.d.ts
+/**
+ * Return every known source column as a named projection object.
+ *
+ * The result can be passed directly to `select()` or spread into a larger
+ * projection, such as `{ ...all(users), displayName: upper(users.name) }`.
+ */
+declare function all<TSource extends AnySource>(source: TSource): SourceColumns<SourceRow<TSource>, SourceIdentity<TSource>, SourceSqlTypeMap<TSource>>;
+type SelectionObject = Record<string, AnyExpression | Omit$1>;
+type Selection = SelectionObject;
+type SelectionItems<TSelection> = TSelection extends SelectionObject ? Extract<TSelection[keyof TSelection], AnyExpression> : never;
+type NullableOutput<TOutput, TExpression, TNullableSources> = [Extract<NullabilityOf<TExpression>, TNullableSources>] extends [never] ? TOutput : TOutput | null;
+type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+type SelectionExpression<TField> = Extract<TField, AnyExpression>;
+type RequiredSelectionKeys<TSelection extends SelectionObject> = { [K in keyof TSelection]-?: [SelectionExpression<TSelection[K]>] extends [never] ? never : Omit$1 extends TSelection[K] ? never : K; }[keyof TSelection];
+type OptionalSelectionKeys<TSelection extends SelectionObject> = { [K in keyof TSelection]-?: [SelectionExpression<TSelection[K]>] extends [never] ? never : Omit$1 extends TSelection[K] ? K : never; }[keyof TSelection];
+type SelectionFieldOutput<TField, TNullableSources> = SelectionExpression<TField> extends (infer TExpression extends AnyExpression) ? NullableOutput<ExpressionOutput<TExpression>, TExpression, TNullableSources> : never;
+type SelectionOutput<TSelection, TNullableSources = never> = TSelection extends SelectionObject ? Simplify<{ -readonly [K in RequiredSelectionKeys<TSelection>]: SelectionFieldOutput<TSelection[K], TNullableSources>; } & { -readonly [K in OptionalSelectionKeys<TSelection>]?: SelectionFieldOutput<TSelection[K], TNullableSources>; }> : never;
+type SelectionRequires<TSelection> = RequiresOf<SelectionItems<TSelection>>;
+type SelectionMetadata<TSelection> = InheritedMetadata<SelectionItems<TSelection>>;
+/** SQL result domains retained for each named projection field. */
+type SelectionSqlTypes<TSelection, TRow extends object = SelectionOutput<TSelection>> = { readonly [K in keyof TRow]: K extends keyof TSelection ? SqlTypeOf<TSelection[K]> : SqlUnknown; };
+//#endregion
+//#region src/query/clauses/group-by.d.ts
+interface GroupByClause<TMetadata = never> extends SelectClause<TMetadata> {
+  readonly clauseKind: 'group-by';
+  readonly expressions: readonly AnyExpression[];
+}
+declare function groupBy<const TExpressions extends readonly AnyExpression[]>(...expressions: TExpressions): GroupByClause<GroupingMeta<TExpressions[number], ColumnGroupingDependencies<TExpressions[number]>> | InheritedMetadata<TExpressions[number]>>;
+//#endregion
+//#region src/query/clauses/joins.d.ts
+type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS' | 'NATURAL';
+interface JoinClause<TSource extends AnySource = AnySource, TMetadata = never> extends SelectClause<TMetadata> {
+  readonly clauseKind: 'join';
+  readonly joinType: JoinType;
+  readonly source: TSource;
+  readonly condition?: BooleanExpression<any>;
+}
+declare function innerJoin<TSource extends AnySource, TCondition extends BooleanExpression<any>>(source: TSource, condition: TCondition): JoinClause<TSource, (MetadataOf<TCondition> extends (infer T) ? T extends MetadataOf<TCondition> ? T extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T : never : never) | Extract<MetadataOf<TSource>, {
+  readonly kind: "requires-outer-source";
+}> | CapabilityMetadataOf<TSource>>;
+declare function leftJoin<TSource extends AnySource, TCondition extends BooleanExpression<any>>(source: TSource, condition: TCondition): JoinClause<TSource, (MetadataOf<TCondition> extends (infer T) ? T extends MetadataOf<TCondition> ? T extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T : never : never) | Extract<MetadataOf<TSource>, {
+  readonly kind: "requires-outer-source";
+}> | CapabilityMetadataOf<TSource> | NullableSourceMeta<ProvidedSourceIdentity<TSource>>>;
+declare function rightJoin<TSource extends AnySource, TCondition extends BooleanExpression<any>>(source: TSource, condition: TCondition): JoinClause<TSource, (MetadataOf<TCondition> extends (infer T) ? T extends MetadataOf<TCondition> ? T extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T : never : never) | Extract<MetadataOf<TSource>, {
+  readonly kind: "requires-outer-source";
+}> | CapabilityMetadataOf<TSource>>;
+declare function fullJoin<TSource extends AnySource, TCondition extends BooleanExpression<any>>(source: TSource, condition: TCondition): JoinClause<TSource, (MetadataOf<TCondition> extends (infer T) ? T extends MetadataOf<TCondition> ? T extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T : never : never) | Extract<MetadataOf<TSource>, {
+  readonly kind: "requires-outer-source";
+}> | CapabilityMetadataOf<TSource>>;
+declare function crossJoin<TSource extends AnySource>(source: TSource): JoinClause<TSource, RequiresOuterMetadataOf<TSource> | CapabilityMetadataOf<TSource>>;
+declare function naturalJoin<TSource extends AnySource>(source: TSource): JoinClause<TSource, RequiresOuterMetadataOf<TSource> | CapabilityMetadataOf<TSource>>;
+//#endregion
+//#region src/query/clauses/from.d.ts
+interface FromClause<TSources extends readonly AnySource[] = readonly AnySource[], TMetadata = RequiresOuterMetadataOf<TSources[number]> | CapabilityMetadataOf<TSources[number]>> extends SelectClause<TMetadata> {
+  readonly clauseKind: 'from';
+  readonly sources: TSources;
+}
+declare function from<const TSources extends readonly [AnySource, ...AnySource[]]>(...sources: TSources): FromClause<TSources, RequiresOuterMetadataOf<TSources[number]> | CapabilityMetadataOf<TSources[number]>>;
+type FromSource<T> = T extends FromClause<infer TSources> ? TSources[number] extends (infer TSource) ? TSource extends Source<any, any, any, any, any> ? [SourceProvision<TSource>] extends [never] ? never : TSource : never : never : never;
+type FromScope<T> = T extends FromClause<infer TSources> ? ProvidedSourceIdentity<TSources[number]> : never;
+//#endregion
+//#region src/query/set.d.ts
+type SetOperator = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'EXCEPT';
+interface SetQuery<TRow extends object = Record<string, unknown>, TCardinality extends QueryCardinality = QueryCardinality, TMetadata = never, TSqlTypes = UnknownSourceSqlTypes<TRow>> extends Query<TRow, TCardinality, TMetadata, TSqlTypes> {
+  readonly queryKind: 'set';
+}
+type SetSqlCompatibilityFailures<TLeft, TRight> = { [K in keyof QuerySqlTypeMap<TLeft>]: K extends keyof QuerySqlTypeMap<TRight> ? SqlEqualityCompatible<QuerySqlTypeMap<TLeft>[K], QuerySqlTypeMap<TRight>[K]> extends true ? never : K : K; }[keyof QuerySqlTypeMap<TLeft>];
+type SetSqlValidation<TLeft, TRight> = [SetSqlCompatibilityFailures<TLeft, TRight>] extends [never] ? unknown : QueryTypeValidation<'incompatible-set-domain', 'set-operation.columns', 'Make corresponding set-operation fields use compatible SQL domains.', SetSqlCompatibilityFailures<TLeft, TRight>>;
+declare function union<TLeft extends Query<any, any, any, any>, TRight extends Query<QueryRow<TLeft>, any, any, any>>(left: TLeft & SetSqlValidation<TLeft, TRight>, right: TRight): SetQuery<QueryRow<TLeft & SetSqlValidation<TLeft, TRight>>, any, CapabilityMetadataOf<TRight | (TLeft & SetSqlValidation<TLeft, TRight>)>, QuerySqlTypeMap<TLeft & SetSqlValidation<TLeft, TRight>>>;
+declare function unionAll<TLeft extends Query<any, any, any, any>, TRight extends Query<QueryRow<TLeft>, any, any, any>>(left: TLeft & SetSqlValidation<TLeft, TRight>, right: TRight): SetQuery<QueryRow<TLeft & SetSqlValidation<TLeft, TRight>>, any, CapabilityMetadataOf<TRight | (TLeft & SetSqlValidation<TLeft, TRight>)>, QuerySqlTypeMap<TLeft & SetSqlValidation<TLeft, TRight>>>;
+declare function intersect<TLeft extends Query<any, any, any, any>, TRight extends Query<QueryRow<TLeft>, any, any, any>>(left: TLeft & SetSqlValidation<TLeft, TRight>, right: TRight): SetQuery<QueryRow<TLeft & SetSqlValidation<TLeft, TRight>>, any, CapabilityMetadataOf<TRight | (TLeft & SetSqlValidation<TLeft, TRight>)>, QuerySqlTypeMap<TLeft & SetSqlValidation<TLeft, TRight>>>;
+declare function except<TLeft extends Query<any, any, any, any>, TRight extends Query<QueryRow<TLeft>, any, any, any>>(left: TLeft & SetSqlValidation<TLeft, TRight>, right: TRight): SetQuery<QueryRow<TLeft & SetSqlValidation<TLeft, TRight>>, any, CapabilityMetadataOf<TRight | (TLeft & SetSqlValidation<TLeft, TRight>)>, QuerySqlTypeMap<TLeft & SetSqlValidation<TLeft, TRight>>>;
+//#endregion
+//#region src/query/clauses/with.d.ts
+type CteIdentity<TName extends string> = {
+  readonly sourceKind: 'cte';
+  readonly name: TName;
+};
+type CteSource<TName extends string, TRow extends object, TMetadata = never, TSqlTypes extends SourceSqlTypes<TRow> = UnknownSourceSqlTypes<TRow>> = Source<CteIdentity<TName>, TRow, TMetadata, TSqlTypes> & {
+  readonly cteName: TName;
+  readonly query: Query<TRow, any, TMetadata, TSqlTypes>;
+  readonly columns: SourceColumns<TRow, CteIdentity<TName>, TSqlTypes>;
+} & SourceColumns<TRow, CteIdentity<TName>, TSqlTypes>;
+type CteMetadata<TQuery extends Query<any, any, any, any>> = RequiresOuterMetadataOf<TQuery> | CapabilityMetadataOf<TQuery>;
+type IsUnknown<T> = unknown extends T ? [keyof T] extends [never] ? true : false : false;
+type RecursiveMemberFieldFailures<TAnchor, TMember> = Exclude<keyof QueryRow<TAnchor>, keyof QueryRow<TMember>> | Exclude<keyof QueryRow<TMember>, keyof QueryRow<TAnchor>> | { [K in keyof QueryRow<TAnchor> & keyof QueryRow<TMember>]: [IsUnknown<QueryRow<TMember>[K]>] extends [true] ? never : [IsUnknown<QueryRow<TAnchor>[K]>] extends [true] ? never : [QueryRow<TMember>[K]] extends [QueryRow<TAnchor>[K]] ? never : K; }[keyof QueryRow<TAnchor> & keyof QueryRow<TMember>];
+type RecursiveMemberShapeValidation<TAnchor, TMember> = [RecursiveMemberFieldFailures<TAnchor, TMember>] extends [never] ? unknown : QueryTypeValidation<'incompatible-set-domain', 'recursive-cte.member', 'The recursive member must expose the anchor fields with compatible application types.', RecursiveMemberFieldFailures<TAnchor, TMember>>;
+type RecursiveMemberValidation<TAnchor, TMember> = RecursiveMemberShapeValidation<TAnchor, TMember> & SetSqlValidation<TAnchor, TMember>;
+type RecursiveCteSelf<TName extends string, TAnchor extends SelectQuery<any, any, any, any>> = CteSource<TName, QueryRow<TAnchor>, CteMetadata<TAnchor>, QuerySqlTypeMap<TAnchor>>;
+/** The typed source returned by {@link recursiveCte}. */
+type RecursiveCteSource<TName extends string, TAnchor extends SelectQuery<any, any, any, any>, TMember extends SelectQuery<any, any, any, any>> = CteSource<TName, QueryRow<TAnchor>, CteMetadata<TAnchor | TMember>, QuerySqlTypeMap<TAnchor>>;
+type AnyCteSource = Source<any, any, any, any, any> & {
+  readonly cteName: string;
+  readonly query: Query<any, any, any> & {
+    readonly recursive?: boolean;
+  };
+  readonly columns: Record<string, unknown>;
+};
+declare function cte<const TName extends string, TQuery extends Query<any, any, any>>(name: TName, query: TQuery): CteSource<TName, QueryRow<TQuery>, RequiresOuterMetadataOf<TQuery> | CapabilityMetadataOf<TQuery>, QuerySqlTypeMap<TQuery>>;
+/**
+ * Define a typed recursive `WITH` source from an anchor and one recursive
+ * member. The callback receives a forward reference that must be introduced
+ * through the member query's normal FROM or JOIN scope.
+ */
+declare function recursiveCte<const TName extends string, TAnchor extends SelectQuery<any, any, any, any>, TMember extends SelectQuery<any, any, any, any>>(name: TName, anchor: TAnchor, member: ((self: RecursiveCteSelf<TName, TAnchor>) => TMember) & ((self: RecursiveCteSelf<TName, TAnchor>) => TMember & RecursiveMemberValidation<NoInfer<TAnchor>, NoInfer<TMember>>)): RecursiveCteSource<TName, TAnchor, TMember>;
+interface WithClause<TMetadata = never> extends SelectClause<TMetadata> {
+  readonly clauseKind: 'with';
+  readonly ctes: readonly AnyCteSource[];
+}
+declare function withCte<const TCtes extends readonly AnyCteSource[]>(...ctes: TCtes): WithClause<RequiresOuterMetadataOf<TCtes[number]> | CapabilityMetadataOf<TCtes[number]>>;
+//#endregion
+//#region src/query/select/types.d.ts
+interface SelectQuery<TRow extends object = Record<string, unknown>, TCardinality extends QueryCardinality = QueryCardinality, TMetadata = never, TSqlTypes = UnknownSourceSqlTypes<TRow>> extends Query<TRow, TCardinality, TMetadata, TSqlTypes> {
+  readonly queryKind: 'select';
+}
+type ExactlyOneSafeClause = DistinctClause | OrderByClause<any> | RowLockClause | WithClause;
+type AtMostOneClause = FetchClause<0 | 1>;
+type UnconditionalAtMostOneClause<TParts extends readonly SelectPart[]> = { [TIndex in keyof TParts]: Omit$1 extends TParts[TIndex] ? never : Extract<TParts[TIndex], AtMostOneClause>; }[number];
+type ConditionalPaginationClause<TParts extends readonly SelectPart[]> = { [TIndex in keyof TParts]: Omit$1 extends TParts[TIndex] ? Extract<TParts[TIndex], AnyPaginationClause> : never; }[number];
+/**
+ * SELECT cardinality is intentionally conservative. A literal FETCH/LIMIT
+ * bound of zero or one proves an upper bound only when it is unconditional;
+ * an otherwise source-free query has one row unless a known row-reducing
+ * clause is present. Conditional pagination, predicates, and arbitrary clauses
+ * do not prove exactness.
+ */
+type SelectCardinality<TParts extends readonly SelectPart[]> = UnconditionalAtMostOneClause<TParts> extends never ? ConditionalPaginationClause<TParts> extends never ? Exclude<TParts[number], ExactlyOneSafeClause | Omit$1> extends never ? 'exactly-one' : 'many' : 'many' : 'zero-or-one';
+type ClauseScope<TClause> = TClause extends FromClause ? FromScope<TClause> : TClause extends JoinClause<infer TSource, any> ? ProvidedSourceIdentity<TSource> : never;
+type AvailableScope<TClauses extends readonly AnySelectClause[]> = ClauseScope<TClauses[number]>;
+type AvailableOuterScope<TClauses extends readonly AnySelectClause[]> = ProvidesOuterOf<TClauses[number]>;
+type NullableSources<TClauses extends readonly AnySelectClause[]> = NullableSourcesOf<TClauses[number]>;
+type RequiredScope<TSelection, TClauses extends readonly AnySelectClause[]> = SelectionRequires<TSelection> | RequiresOuterOf<SelectionItems<TSelection>> | RequiresOf<TClauses[number]> | RequiresOuterOf<TClauses[number]>;
+type MissingScope<TSelection, TClauses extends readonly AnySelectClause[]> = Exclude<RequiredScope<TSelection, TClauses>, AvailableScope<TClauses> | AvailableOuterScope<TClauses>>;
+type RequiredOuterScope<TSelection, TClauses extends readonly AnySelectClause[]> = Extract<Exclude<RequiredScope<TSelection, TClauses>, AvailableScope<TClauses>>, AvailableOuterScope<TClauses>>;
+type ScopeValidation<TSelection, TClauses extends readonly AnySelectClause[]> = [MissingScope<TSelection, TClauses>] extends [never] ? unknown : QueryTypeValidation<'missing-source', 'select.scope', 'Add a FROM, JOIN, or correlate() clause that provides the referenced source.', MissingScope<TSelection, TClauses>>;
+type GroupingRuleClause = HavingClause<any> | OrderByClause<any>;
+type HasGroupByClause<TClauses extends readonly AnySelectClause[]> = Extract<TClauses[number], GroupByClause<any>> extends never ? false : true;
+type HasHavingClause<TClauses extends readonly AnySelectClause[]> = Extract<TClauses[number], HavingClause<any>> extends never ? false : true;
+type GroupingRuleClauses<TClauses extends readonly AnySelectClause[]> = Extract<TClauses[number], GroupingRuleClause>;
+type RequiresGrouping<TSelection, TClauses extends readonly AnySelectClause[]> = HasGroupByClause<TClauses> extends true ? true : HasHavingClause<TClauses> extends true ? true : HasAggregate<SelectionItems<TSelection> | GroupingRuleClauses<TClauses>>;
+type ClauseSource<TClause> = TClause extends FromClause ? FromSource<TClause> : TClause extends JoinClause<infer TSource, any> ? TSource : never;
+type ConstraintDeterminesSource<TConstraint, TSource extends AnySource, TGroupedDependencies> = TConstraint extends {
+  readonly kind: 'primary-key' | 'unique';
+  readonly columns: infer TColumns;
+} ? TColumns extends readonly ColumnReference<string, any>[] ? [DependenciesOf<TColumns[number]>] extends [ColumnDependency<any, any>] ? [ColumnDependency<SourceIdentity<TSource>, DependenciesOf<TColumns[number]> extends ColumnDependency<any, infer TName extends string> ? TName : never>] extends [TGroupedDependencies] ? true : false : false : false : false;
+type IndexTermExpression$2<T> = T extends OrderTerm<any> ? T['expression'] : T;
+type IndexDeterminesSource<TIndex, TSource extends AnySource, TGroupedDependencies> = TIndex extends {
+  readonly candidateKey: true;
+  readonly terms: infer TTerms extends readonly unknown[];
+} ? [DependenciesOf<IndexTermExpression$2<TTerms[number]>>] extends [ColumnDependency<any, any>] ? [ColumnDependency<SourceIdentity<TSource>, DependenciesOf<IndexTermExpression$2<TTerms[number]>> extends ColumnDependency<any, infer TName extends string> ? TName : never>] extends [TGroupedDependencies] ? true : false : false : false;
+type SourceIndexes<T> = T extends {
+  readonly indexes: infer TIndexes extends SourceIndexesRecord;
+} ? TIndexes : {};
+type DeterminedSourceIdentity<TSource, TGroupedDependencies> = TSource extends AnySource ? true extends ConstraintDeterminesSource<SourceConstraints<TSource>[keyof SourceConstraints<TSource>], TSource, TGroupedDependencies> ? SourceIdentity<TSource> : true extends IndexDeterminesSource<SourceIndexes<TSource>[keyof SourceIndexes<TSource>], TSource, TGroupedDependencies> ? SourceIdentity<TSource> : never : never;
+type FunctionallyDeterminedDependencies<TClauses extends readonly AnySelectClause[]> = ColumnDependency<DeterminedSourceIdentity<ClauseSource<TClauses[number]>, GroupingDependenciesOf<TClauses[number]>>, string>;
+type GroupingFailure<TExpression, TClauses extends readonly AnySelectClause[]> = TExpression extends unknown ? [VisibleDependenciesOf<TExpression>] extends [never] ? never : [Exclude<VisibleDependenciesOf<TExpression>, GroupingDependenciesOf<TClauses[number]> | FunctionallyDeterminedDependencies<TClauses>>] extends [never] ? never : [Extract<TExpression, GroupingKeysOf<TClauses[number]>>] extends [never] ? VisibleDependenciesOf<TExpression> : never : never;
+type SelectionGroupingFailures<TSelection, TClauses extends readonly AnySelectClause[]> = GroupingFailure<SelectionItems<TSelection>, TClauses>;
+type ClauseGroupingFailures<TClauses extends readonly AnySelectClause[]> = TClauses[number] extends (infer TClause) ? TClause extends GroupingRuleClause ? GroupingFailure<TClause, TClauses> : never : never;
+type GroupByAggregateFailures<TClauses extends readonly AnySelectClause[]> = TClauses[number] extends (infer TClause) ? TClause extends GroupByClause<any> ? HasAggregate<TClause> extends true ? TClause : never : never : never;
+type GroupingFailures<TSelection, TClauses extends readonly AnySelectClause[]> = SelectionGroupingFailures<TSelection, TClauses> | ClauseGroupingFailures<TClauses> | GroupByAggregateFailures<TClauses>;
+/**
+ * Enforce the grouped-query rule: visible column dependencies must be grouped
+ * or functionally determined by a grouped, declared key from the same source.
+ * Aggregate arguments are consumed by the aggregate. Non-column GROUP BY
+ * expressions are accepted as exact grouping keys only.
+ */
+type GroupingValidation<TSelection, TClauses extends readonly AnySelectClause[]> = RequiresGrouping<TSelection, TClauses> extends true ? [GroupingFailures<TSelection, TClauses>] extends [never] ? unknown : QueryTypeValidation<'invalid-grouping', 'select.grouping', 'Group every visible dependency or project it through an aggregate.', GroupingFailures<TSelection, TClauses>> : unknown;
+//#endregion
+//#region src/query/select.d.ts
+type SelectMetadata<TSelection, TClauses extends readonly AnySelectClause[]> = ([RequiredOuterScope<TSelection, TClauses>] extends [never] ? never : RequiresOuterSourceMeta<RequiredOuterScope<TSelection, TClauses>>) | CapabilityMetadataOf<SelectionItems<TSelection> | TClauses[number]>;
+declare function select<const TSelection extends Selection, const TParts extends readonly SelectPart[], TClauses extends readonly AnySelectClause[] = PresentClauses<TParts>>(selection: TSelection, ...parts: TParts & OmissionValidation<TParts> & ScopeValidation<TSelection, TClauses> & GroupingValidation<TSelection, TClauses>): SelectQuery<SelectionOutput<TSelection, NullableSources<TClauses>>, SelectCardinality<TParts>, SelectMetadata<TSelection, TClauses>, SelectionSqlTypes<TSelection, SelectionOutput<TSelection, NullableSources<TClauses>>>>;
+//#endregion
+//#region src/query/clauses/correlate.d.ts
+/**
+ * Provision an enclosing source to a correlated SELECT. The clause emits no
+ * SQL; select() consumes the provision and records any actually used source
+ * as a requirement on the resulting query.
+ */
+interface CorrelateClause<TSources extends readonly AnySource[] = readonly AnySource[]> extends SelectClause<ProvidesOuterSourceMeta<SourceIdentity<TSources[number]>>> {
+  readonly clauseKind: 'correlate';
+  readonly sources: TSources;
+}
+declare function correlate<const TSources extends readonly [AnySource, ...AnySource[]]>(...sources: TSources): CorrelateClause<TSources>;
+//#endregion
+//#region src/query/mutation/returning.d.ts
+interface ReturningClause<TSelection extends Selection = Selection> extends Fragment<SelectionMetadata<TSelection>> {
+  readonly clauseKind: 'returning';
+  readonly selection: TSelection;
+  readonly row: SelectionOutput<TSelection>;
+}
+type ReturningRow<T> = [T] extends [ReturningClause<infer TSelection>] ? SelectionOutput<TSelection> : Record<string, never>;
+/** SQL semantic domains retained by a mutation RETURNING projection. */
+type ReturningSqlTypes<T> = [T] extends [ReturningClause<infer TSelection>] ? SelectionSqlTypes<TSelection> : Record<string, never>;
+declare function returning<const TSelection extends Selection>(selection: TSelection): ReturningClause<TSelection>;
+//#endregion
+//#region src/query/mutation/types.d.ts
+type MutationKind = 'insert' | 'update' | 'delete';
+interface MutationQuery<TRow extends object = Record<string, unknown>, TKind extends MutationKind = MutationKind, TMetadata = never, TSqlTypes = UnknownSourceSqlTypes<TRow>> extends Query<TRow, 'many', TMetadata, TSqlTypes> {
+  readonly queryKind: TKind;
+}
+type MutationCapabilityMetadata<T> = CapabilityMetadataOf<T>;
+interface AllowAllClause extends Fragment<never> {
+  readonly clauseKind: 'allow-all';
+}
+declare function allowAll(): AllowAllClause;
+type MutationConditionClause = WhereClause<any>;
+type MutationClause = MutationConditionClause | AllowAllClause | MutationReturningClause;
+type MutationSafetyValidation<TClauses extends readonly unknown[]> = Extract<TClauses[number], MutationConditionClause | AllowAllClause> extends never ? QueryTypeValidation<'unsafe-mutation', 'mutation.safety', 'Add where(...) or allowAll() explicitly.'> : unknown;
+type MutationReturningClause = ReturningClause<any>;
+type MutationReturning<TClauses extends readonly unknown[]> = Extract<TClauses[number], MutationReturningClause>;
+type MutationRow<TClauses extends readonly unknown[]> = ReturningRow<MutationReturning<TClauses>>;
+type MutationSqlTypes<TClauses extends readonly unknown[]> = ReturningSqlTypes<MutationReturning<TClauses>>;
+type MutationScopeValidation<TSource, TClauses extends readonly unknown[]> = [Exclude<RequiresOf<TClauses[number]>, SourceIdentity<TSource>>] extends [never] ? unknown : QueryTypeValidation<'missing-source', 'mutation.scope', 'Use clauses that reference the mutation table or an explicitly correlated source.', Exclude<RequiresOf<TClauses[number]>, SourceIdentity<TSource>>>;
+//#endregion
+//#region src/query/mutation/update.d.ts
+/** A value, target-compatible expression, or explicitly omitted update field. */
+type UpdateAssignmentValue<T> = T | ExpressionWithOutput<T> | Omit$1;
+/** Writable table fields accepted by {@link update}. */
+type UpdateAssignments<TTable extends AnyTable> = { -readonly [K in keyof TableUpdateInput<TTable['definitions']>]?: UpdateAssignmentValue<TableUpdateInput<TTable['definitions']>[K]>; };
+type InvalidUpdateAssignments<TTable extends AnyTable, TAssignments> = TAssignments extends UpdateAssignments<TTable> ? Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>> extends never ? unknown : QueryTypeValidation<'invalid-update', 'update.assignments', 'Use only columns declared by the update table.', Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>>> : QueryTypeValidation<'invalid-update', 'update.assignments', 'Provide values or expressions matching the update table columns.', TAssignments>;
+type AssignmentScopeValidation<TTable extends AnyTable, TAssignments> = [Exclude<RequiresOf<TAssignments extends object ? TAssignments[keyof TAssignments] : never>, SourceIdentity<TTable>>] extends [never] ? unknown : QueryTypeValidation<'missing-source', 'update.assignments', 'Use expressions scoped to the update table.', Exclude<RequiresOf<TAssignments extends object ? TAssignments[keyof TAssignments] : never>, SourceIdentity<TTable>>>;
+declare function update<const TTable extends AnyTable, const TAssignments extends object, const TClauses extends readonly MutationClause[]>(table: TTable, assignments: TAssignments & InvalidUpdateAssignments<TTable, TAssignments> & AssignmentScopeValidation<TTable, TAssignments>, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses> & MutationSafetyValidation<TClauses>): MutationQuery<MutationRow<TClauses>, 'update', MutationCapabilityMetadata<TClauses[number] | (TAssignments extends object ? TAssignments[keyof TAssignments] : never)>, MutationSqlTypes<TClauses>>;
+//#endregion
+//#region src/query/mutation/on-conflict.d.ts
+type ExcludedIdentity<TTableIdentity> = {
+  readonly sourceKind: 'excluded';
+  readonly table: TTableIdentity;
+};
+type ExcludedSource<TTable extends AnyTable> = Source<ExcludedIdentity<SourceIdentity<TTable>>, SourceRow<TTable>, never, ExcludedSqlTypes<TTable>> & SourceColumns<SourceRow<TTable>, ExcludedIdentity<SourceIdentity<TTable>>, ExcludedSqlTypes<TTable>>;
+type ExcludedSqlTypes<TTable extends AnyTable> = SourceSqlTypeMap<TTable> & SourceSqlTypes<SourceRow<TTable>>;
+/** Columns from the proposed INSERT row, available inside DO UPDATE. */
+declare function excluded<const TTable extends AnyTable>(table: TTable): ExcludedSource<TTable>;
+interface DoNothingAction {
+  readonly actionKind: 'do-nothing';
+}
+interface DoUpdateAction<TAssignments extends object = object, TWhere extends WhereClause<any> | undefined = WhereClause<any> | undefined> {
+  readonly actionKind: 'do-update';
+  readonly assignments: TAssignments;
+  readonly where: TWhere;
+}
+type ConflictAction = DoNothingAction | DoUpdateAction<any, any>;
+declare function doNothing(): DoNothingAction;
+declare function doUpdate<const TAssignments extends object>(assignments: TAssignments): DoUpdateAction<TAssignments, undefined>;
+declare function doUpdate<const TAssignments extends object, const TWhere extends WhereClause<any>>(assignments: TAssignments, whereClause: TWhere): DoUpdateAction<TAssignments, TWhere>;
+type TableConstraints<TTable extends AnyTable> = TTable extends {
+  readonly constraints: infer TConstraints extends SourceConstraintsRecord;
+} ? TConstraints : never;
+type TableKeyConstraint<TTable extends AnyTable> = Extract<TableConstraints<TTable>[keyof TableConstraints<TTable>], KeyConstraint>;
+/** A declared primary or non-null unique key used as an upsert target. */
+type ConflictTarget<TTable extends AnyTable = AnyTable> = TableKeyConstraint<TTable>;
+type ConflictSources<TTable extends AnyTable> = SourceIdentity<TTable> | ExcludedIdentity<SourceIdentity<TTable>>;
+type ConflictAssignmentValidation<TTable extends AnyTable, TAssignments> = TAssignments extends UpdateAssignments<TTable> ? Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>> extends never ? [Exclude<RequiresOf<TAssignments[keyof TAssignments]>, ConflictSources<TTable>>] extends [never] ? unknown : QueryTypeValidation<'missing-source', 'upsert.update.assignments', 'Use expressions scoped to the target table or excluded row.', Exclude<RequiresOf<TAssignments[keyof TAssignments]>, ConflictSources<TTable>>> : QueryTypeValidation<'invalid-update', 'upsert.update.assignments', 'Use only writable columns declared by the target table.', Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>>> : QueryTypeValidation<'invalid-update', 'upsert.update.assignments', 'Provide values or expressions matching the target table update columns.', TAssignments>;
+type ConflictWhereValidation<TTable extends AnyTable, TWhere> = TWhere extends undefined ? unknown : [Exclude<RequiresOf<TWhere>, ConflictSources<TTable>>] extends [never] ? unknown : QueryTypeValidation<'missing-source', 'upsert.update.where', 'Use expressions scoped to the target table or excluded row.', Exclude<RequiresOf<TWhere>, ConflictSources<TTable>>>;
+type ConflictActionValidation<TTable extends AnyTable, TAction extends ConflictAction> = TAction extends DoUpdateAction<infer TAssignments, infer TWhere> ? ConflictAssignmentValidation<TTable, TAssignments> & ConflictWhereValidation<TTable, TWhere> : unknown;
+type ConflictActionCapabilities<TAction extends ConflictAction> = TAction extends DoUpdateAction<infer TAssignments, infer TWhere> ? CapabilityMetadataOf<TAssignments[keyof TAssignments] | Exclude<TWhere, undefined>> : never;
+interface OnConflictClause<TAction extends ConflictAction = ConflictAction> extends Fragment<RequiresCapabilityMeta<'on-conflict'> | ConflictActionCapabilities<TAction>> {
+  readonly clauseKind: 'on-conflict';
+  readonly target: KeyConstraint | undefined;
+  readonly action: TAction;
+}
+type InsertClause = MutationReturningClause | OnConflictClause;
+declare function onConflict(action: DoNothingAction): OnConflictClause<DoNothingAction>;
+declare function onConflict<const TTable extends AnyTable, const TTarget extends ConflictTarget<TTable>, const TAction extends ConflictAction>(table: TTable, target: TTarget, action: TAction & ConflictActionValidation<TTable, TAction>): OnConflictClause<TAction>;
+//#endregion
+//#region src/query/mutation/insert.d.ts
+interface ValuesSource<TRows extends readonly object[] = readonly object[]> {
+  readonly insertKind: 'values';
+  readonly rows: TRows;
+}
+declare function values<const TRows extends readonly [object, ...object[]]>(...rows: TRows): ValuesSource<TRows>;
+interface DefaultValuesSource {
+  readonly insertKind: 'default-values';
+}
+declare function defaultValues(): DefaultValuesSource;
+interface InsertSelectSource<TQuery extends Query<any, any, any> = Query<any, any, any>, TColumns extends readonly string[] = readonly string[]> {
+  readonly insertKind: 'select';
+  readonly query: TQuery;
+  readonly columns: TColumns;
+}
+declare function insertSelect<TQuery extends Query<any, any, any>, const TColumns extends readonly [string, ...string[]]>(query: TQuery, columns: TColumns): InsertSelectSource<TQuery, TColumns>;
+type InsertSource = ValuesSource<any> | DefaultValuesSource | InsertSelectSource<any, any>;
+type InsertSourceCapabilityMetadata<TSource extends InsertSource> = TSource extends InsertSelectSource<infer TQuery, any> ? CapabilityMetadataOf<TQuery> : never;
+type InsertRow<TTable extends AnyTable> = TableInsertInput<TTable['definitions']>;
+type InvalidInsertRow<TTable extends AnyTable, TRow> = TRow extends InsertRow<TTable> ? Exclude<keyof TRow, keyof InsertRow<TTable>> extends never ? unknown : QueryTypeValidation<'invalid-insert', 'insert.values.columns', 'Use only columns declared by the insert table.', Exclude<keyof TRow, keyof InsertRow<TTable>>> : QueryTypeValidation<'invalid-insert', 'insert.values.row', 'Provide values matching the insert table columns.', TRow>;
+type ValidInsertSource<TTable extends AnyTable, TSource extends InsertSource> = TSource extends ValuesSource<infer TRows> ? TRows[number] extends (infer TRow) ? InvalidInsertRow<TTable, TRow> : never : TSource extends DefaultValuesSource ? Exclude<keyof TTable['definitions'], { [K in keyof TTable['definitions']]-?: ColumnIsGenerated<TTable['definitions'][K]> extends true ? K : TTable['definitions'][K] extends {
+  hasDefault: true;
+} ? K : never; }[keyof TTable['definitions']]> extends never ? unknown : QueryTypeValidation<'invalid-insert', 'insert.default-values', 'Provide values for required columns or define defaults for them.', Exclude<keyof TTable['definitions'], { [K in keyof TTable['definitions']]-?: ColumnIsGenerated<TTable['definitions'][K]> extends true ? K : TTable['definitions'][K] extends {
+  hasDefault: true;
+} ? K : never; }[keyof TTable['definitions']]>> : TSource extends InsertSelectSource<any, infer TColumns> ? Exclude<TColumns[number], keyof TTable['definitions']> extends never ? Exclude<{ [K in keyof TTable['definitions']]-?: ColumnIsGenerated<TTable['definitions'][K]> extends true ? never : ColumnHasDefault<TTable['definitions'][K]> extends true ? never : K; }[keyof TTable['definitions']], TColumns[number]> extends never ? unknown : QueryTypeValidation<'invalid-insert', 'insert.select.columns', 'Include every required insert column in the target list.', Exclude<{ [K in keyof TTable['definitions']]-?: ColumnIsGenerated<TTable['definitions'][K]> extends true ? never : ColumnHasDefault<TTable['definitions'][K]> extends true ? never : K; }[keyof TTable['definitions']], TColumns[number]>> : QueryTypeValidation<'invalid-insert', 'insert.select.columns', 'Use only columns declared by the insert table.', Exclude<TColumns[number], keyof TTable['definitions']>> : never;
+declare function insertInto<const TTable extends AnyTable, const TSource extends InsertSource, const TClauses extends readonly InsertClause[]>(table: TTable, source: TSource & ValidInsertSource<TTable, TSource>, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses>): MutationQuery<MutationRow<TClauses>, 'insert', MutationCapabilityMetadata<TClauses[number]> | InsertSourceCapabilityMetadata<TSource>, MutationSqlTypes<TClauses>>;
+//#endregion
+//#region src/query/mutation/delete.d.ts
+declare function deleteFrom<const TTable extends AnyTable, const TClauses extends readonly MutationClause[]>(table: TTable, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses> & MutationSafetyValidation<TClauses>): MutationQuery<MutationRow<TClauses>, 'delete', MutationCapabilityMetadata<TClauses[number]>, MutationSqlTypes<TClauses>>;
+//#endregion
+//#region src/query/clauses/order-by.d.ts
+type OrderDirection = 'ASC' | 'DESC';
+type NullsOrder = 'FIRST' | 'LAST';
+interface OrderTerm<TMetadata = never, TExpression extends AnyExpression = AnyExpression> extends Fragment<TMetadata> {
+  readonly orderKind: 'term';
+  readonly expression: TExpression;
+  readonly direction?: OrderDirection;
+  readonly nulls?: NullsOrder;
+}
+declare function order<TExpression extends AnyExpression>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable>, direction?: OrderDirection, nulls?: NullsOrder): OrderTerm<MetadataOf<TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>> extends (infer T) ? T extends MetadataOf<TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>> ? T extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T : never : never, TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>>;
+declare function asc<TExpression extends AnyExpression>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable>, nulls?: NullsOrder): OrderTerm<MetadataOf<TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>> extends (infer T) ? T extends MetadataOf<TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>> ? T extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T : never : never, TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>>;
+declare function desc<TExpression extends AnyExpression>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable>, nulls?: NullsOrder): OrderTerm<MetadataOf<TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>> extends (infer T) ? T extends MetadataOf<TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>> ? T extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T : never : never, TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>>;
+declare function nullsFirst<TExpression extends AnyExpression>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable>): OrderTerm<MetadataOf<TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>> extends (infer T) ? T extends MetadataOf<TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>> ? T extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T : never : never, TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>>;
+declare function nullsLast<TExpression extends AnyExpression>(expression: TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable>): OrderTerm<MetadataOf<TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>> extends (infer T) ? T extends MetadataOf<TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>> ? T extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T : never : never, TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>>;
+interface OrderByClause<TMetadata = never> extends SelectClause<TMetadata> {
+  readonly clauseKind: 'order-by';
+  readonly terms: readonly OrderTerm<any>[];
+}
+type OrderByPart = AnyExpression | OrderTerm<any> | Omit$1;
+type PresentOrderParts<TParts extends readonly OrderByPart[]> = Exclude<TParts[number], Omit$1>;
+type OrderByComposition<TParts extends readonly OrderByPart[]> = [PresentOrderParts<TParts>] extends [never] ? Omit$1 : OrderByClause<InheritedMetadata<PresentOrderParts<TParts>>> | (Omit$1 extends TParts[number] ? Omit$1 : never);
+type OrderPartsValidation<TParts extends readonly unknown[]> = TParts extends readonly [infer THead, ...infer TTail] ? (THead extends Omit$1 ? unknown : THead extends AnyExpression ? SqlCapabilityValidation<ExpressionSqlType<THead>, SqlOrderable> : unknown) & OrderPartsValidation<TTail> : unknown;
+declare function orderBy<const TParts extends readonly OrderByPart[]>(...parts: TParts & OrderPartsValidation<TParts>): OrderByComposition<TParts>;
+//#endregion
+//#region src/schema/indexes.d.ts
+type IndexTerm = AnyExpression | OrderTerm<any>;
+/** PostgreSQL-specific index method and storage metadata. */
+interface PostgresIndexExtension extends SchemaDialectExtension<'postgresql'> {
+  readonly method?: 'btree' | 'hash' | 'gist' | 'spgist' | 'gin' | 'brin';
+  readonly concurrently?: boolean;
+  readonly operatorClasses?: Readonly<Record<string, string>>;
+  readonly storageParameters?: Readonly<Record<string, string | number | boolean>>;
+}
+/** SQLite-specific index metadata retained for a future adapter. */
+interface SqliteIndexExtension extends SchemaDialectExtension<'sqlite'> {
+  readonly auto?: boolean;
+}
+/** MySQL-specific index algorithm, locking, and parser metadata. */
+interface MysqlIndexExtension extends SchemaDialectExtension<'mysql'> {
+  readonly algorithm?: 'default' | 'inplace' | 'copy';
+  readonly lock?: 'default' | 'none' | 'shared' | 'exclusive';
+  readonly using?: 'btree' | 'hash' | 'rtree';
+  readonly parser?: string;
+  readonly keyBlockSize?: number;
+}
+/** First-party and user-defined dialect extensions for indexes. */
+type IndexDialectExtension = PostgresIndexExtension | SqliteIndexExtension | MysqlIndexExtension | (SchemaDialectExtension<string> & Readonly<Record<string, unknown>>);
+interface IndexOptions<TPredicate extends AnyExpression | undefined = AnyExpression | undefined, TExtension extends IndexDialectExtension | undefined = IndexDialectExtension | undefined> extends SchemaObjectNameOptions {
+  readonly unique?: boolean;
+  readonly where?: TPredicate;
+  /** Columns stored in the index payload but not used as key terms. */
+  readonly include?: readonly ColumnReference<string, any>[];
+  /** Typed engine-specific index options. */
+  readonly dialect?: TExtension;
+}
+type IndexTermExpression$1<TTerm> = TTerm extends OrderTerm<any> ? TTerm['expression'] : TTerm;
+type IsNullableIndexColumn<TColumn> = [DeclaredColumnNullabilityOf<TColumn>] extends [never] ? null extends OutputOf<TColumn> ? true : false : true extends DeclaredColumnNullabilityOf<TColumn> ? true : false;
+type IsEligibleColumn<TTerm> = IndexTermExpression$1<TTerm> extends (infer TExpression) ? TExpression extends ColumnReference<string, any> ? IsNullableIndexColumn<TExpression> extends true ? false : true : false : false;
+type AllEligibleColumns<TTerms extends readonly IndexTerm[]> = { [K in keyof TTerms]: IsEligibleColumn<TTerms[K]>; }[number] extends (infer TEligibility) ? false extends TEligibility ? true extends TEligibility ? boolean : false : true : false;
+type BooleanOption<TValue> = [Extract<TValue, true>] extends [never] ? false : [Exclude<TValue, true>] extends [never] ? true : boolean;
+type UniqueOption<TOptions> = 'unique' extends keyof TOptions ? BooleanOption<TOptions['unique']> : false;
+type PredicateOption<TOptions> = 'where' extends keyof TOptions ? TOptions['where'] : undefined;
+type DialectOption<TOptions> = TOptions extends {
+  readonly dialect?: infer TDialect;
+} ? unknown extends TDialect ? IndexDialectExtension | undefined : TDialect : undefined;
+type PredicatePresence<TOptions> = [Exclude<PredicateOption<TOptions>, undefined>] extends [never] ? false : undefined extends PredicateOption<TOptions> ? boolean : true;
+type IsCandidateKey<TTerms extends readonly IndexTerm[], TOptions extends IndexOptions<any>> = UniqueOption<TOptions> extends (infer TUnique) ? PredicatePresence<TOptions> extends (infer THasPredicate) ? AllEligibleColumns<TTerms> extends (infer TEligible) ? TUnique extends false ? false : THasPredicate extends true ? false : TEligible extends false ? false : TUnique extends true ? THasPredicate extends false ? TEligible extends true ? true : boolean : boolean : boolean : false : false : false;
+/** Portable index metadata retained by a table and its aliases. */
+interface TableIndex<TTerms extends readonly IndexTerm[] = any, TOptions extends IndexOptions<any> = any> extends SchemaObjectIdentity {
+  readonly kind: 'index';
+  readonly terms: TTerms;
+  readonly unique: UniqueOption<TOptions>;
+  readonly predicate: PredicateOption<TOptions>;
+  readonly includedColumns?: TOptions extends {
+    readonly include: infer TIncluded;
+  } ? TIncluded : undefined;
+  readonly dialect?: DialectOption<TOptions>;
+  readonly candidateKey: IsCandidateKey<TTerms, TOptions>;
+}
+/** The widened index shape accepted by source metadata records. */
+interface SourceIndex {
+  readonly kind: 'index';
+  readonly terms: readonly IndexTerm[];
+  readonly unique: boolean;
+  readonly predicate: AnyExpression | undefined;
+  readonly includedColumns?: readonly ColumnReference<string, any>[];
+  readonly dialect?: IndexDialectExtension;
+  readonly candidateKey: boolean;
+}
+type SourceIndexesRecord = Readonly<Record<string, SourceIndex>>;
+/**
+ * Validate portable and dialect-owned index facts for one target adapter.
+ * Unsupported features are reported as data so a serializer can aggregate
+ * diagnostics instead of failing during traversal with an opaque exception.
+ */
+declare function validateIndexDialect(indexMetadata: SourceIndex, dialect: string, path?: readonly (string | number)[]): readonly SchemaMetadataDiagnostic[];
+type ValidIndexExpression<T> = T extends AnyExpression ? HasAggregate<T> extends true ? never : HasWindow<T> extends true ? never : HasSubquery<T> extends true ? never : unknown : never;
+type InvalidIndexTerms<TTerms extends readonly IndexTerm[]> = { [K in keyof TTerms]: TTerms[K] extends OrderTerm<any> ? TTerms[K] extends {
+  readonly nulls: 'FIRST' | 'LAST';
+} ? TTerms[K] : ValidIndexExpression<TTerms[K]['expression']> extends never ? TTerms[K] : never : ValidIndexExpression<TTerms[K]> extends never ? TTerms[K] : never; }[number];
+type IndexTermsValidation<TTerms extends readonly IndexTerm[]> = [InvalidIndexTerms<TTerms>] extends [never] ? unknown : never;
+/** Declare a portable column or expression index. */
+declare function index<const TTerms extends readonly [IndexTerm, ...IndexTerm[]], const TOptions extends IndexOptions<any> = {}>(terms: TTerms & IndexTermsValidation<NoInfer<TTerms>>, options?: TOptions): TableIndex<TTerms, TOptions>;
+//#endregion
+//#region src/schema/table.d.ts
+type TableDefinitions = Record<string, ColumnDefinition<any, any, any, any, any, any, any, any, any, any, any>>;
+type AnyTable = Source<any, any, any, any, any> & {
+  readonly tableName: string;
+  readonly definitions: TableDefinitions;
+  /** Application field keys mapped to physical SQL column names. */
+  readonly sqlNames: Readonly<Record<string, string>>;
+};
+type TableRow<TDefinitions extends TableDefinitions> = { -readonly [K in keyof TDefinitions]: ColumnOutput<TDefinitions[K]>; };
+/** SQL semantic domains derived from a table's column definitions. */
+type TableSqlTypes<TDefinitions extends TableDefinitions> = { readonly [K in keyof TDefinitions]: ColumnSqlType<TDefinitions[K]>; };
+type RequiredInsertKeys<TDefinitions extends TableDefinitions> = { [K in keyof TDefinitions]-?: ColumnHasDefault<TDefinitions[K]> extends true ? never : ColumnIsGenerated<TDefinitions[K]> extends true ? never : K; }[keyof TDefinitions];
+type OptionalInsertKeys<TDefinitions extends TableDefinitions> = Exclude<keyof TDefinitions, RequiredInsertKeys<TDefinitions>>;
+type TableInsertInput<TDefinitions extends TableDefinitions> = { -readonly [K in RequiredInsertKeys<TDefinitions>]: ColumnInsertInput<TDefinitions[K]>; } & { -readonly [K in OptionalInsertKeys<TDefinitions>]?: ColumnInsertInput<TDefinitions[K]>; };
+type TableUpdateInput<TDefinitions extends TableDefinitions> = { -readonly [K in keyof TDefinitions as ColumnIsGenerated<TDefinitions[K]> extends true ? never : K]?: ColumnUpdateInput<TDefinitions[K]>; };
+type TableIdentity<TName extends string> = {
+  readonly sourceKind: 'table';
+  readonly tableName: TName;
+};
+type TableColumns<TDefinitions extends TableDefinitions, TIdentity> = { readonly [K in keyof TDefinitions]: SourceColumns<TableRow<TDefinitions>, TIdentity, TableSqlTypes<TDefinitions>>[K] & DeclaredColumnNullability<ColumnIsNullable<TDefinitions[K]>>; };
+type Table<TName extends string = string, TDefinitions extends TableDefinitions = TableDefinitions, TConstraints extends SourceConstraintsRecord = {}, TIndexes extends SourceIndexesRecord = {}> = Source<TableIdentity<TName>, TableRow<TDefinitions>, never, TableSqlTypes<TDefinitions>, TConstraints> & {
+  readonly tableName: TName;
+  readonly definitions: TDefinitions;
+  /** Application field keys mapped to physical SQL column names. */
+  readonly sqlNames: Readonly<Record<keyof TDefinitions & string, string>>;
+  readonly columns: TableColumns<TDefinitions, TableIdentity<TName>>;
+  readonly constraints: TConstraints;
+  readonly indexes: TIndexes;
+} & TableColumns<TDefinitions, TableIdentity<TName>>;
+/** Schema metadata that applies to a table as a relation. */
+interface TableOptions<TConstraints extends SourceConstraintsRecord = SourceConstraintsRecord, TIndexes extends SourceIndexesRecord = SourceIndexesRecord> {
+  readonly constraints: TConstraints;
+  readonly indexes: TIndexes;
+}
+type ConstraintColumns<TConstraint> = TConstraint extends KeyConstraint<any, infer TColumns> | UniqueConstraint<infer TColumns> | ForeignKeyConstraint<infer TColumns, any> ? TColumns[number] : never;
+type InvalidConstraintDependencies<TName extends string, TConstraints extends SourceConstraintsRecord> = Exclude<DependenciesOf<ConstraintColumns<TConstraints[keyof TConstraints]>>, ColumnDependency<TableIdentity<TName>, string>>;
+type InvalidExpression<TExpression, TName extends string> = TExpression extends AnyExpression ? Exclude<DependenciesOf<TExpression>, ColumnDependency<TableIdentity<TName>, string>> extends never ? HasAggregate<TExpression> extends true ? TExpression : HasWindow<TExpression> extends true ? TExpression : HasSubquery<TExpression> extends true ? TExpression : never : TExpression : TExpression;
+type ResolvedTarget<T> = T extends (() => infer TResolved) ? TResolved : T;
+type SameColumnTuple<TLeft extends readonly unknown[], TRight extends readonly unknown[]> = TLeft extends readonly [infer TLeftHead, ...infer TLeftTail] ? TRight extends readonly [infer TRightHead, ...infer TRightTail] ? [DependenciesOf<TLeftHead>] extends [DependenciesOf<TRightHead>] ? [DependenciesOf<TRightHead>] extends [DependenciesOf<TLeftHead>] ? SameColumnTuple<TLeftTail, TRightTail> : false : false : false : TRight extends readonly [] ? true : false;
+type IndexTermExpression<T> = T extends OrderTerm<any> ? T['expression'] : T;
+type IndexColumns<TTerms extends readonly IndexTerm[]> = { [K in keyof TTerms]: IndexTermExpression<TTerms[K]>; };
+type IndexIncludedColumns<TIndex> = TIndex extends {
+  readonly includedColumns?: infer TIncluded;
+} ? Exclude<TIncluded, undefined> extends readonly unknown[] ? Exclude<TIncluded, undefined> : never : never;
+type InvalidIncludedColumns<TIncluded, TName extends string> = TIncluded extends readonly unknown[] ? Exclude<DependenciesOf<TIncluded[number]>, ColumnDependency<TableIdentity<TName>, string>> : never;
+type ConstraintsOf<T> = T extends {
+  readonly constraints: infer TConstraints extends SourceConstraintsRecord;
+} ? TConstraints : {};
+type IndexesOf<T> = T extends {
+  readonly indexes: infer TIndexes extends SourceIndexesRecord;
+} ? TIndexes : {};
+type HasMatchingConstraint<TColumns, TConstraints> = TConstraints extends SourceConstraintsRecord ? true extends { [K in keyof TConstraints]: TConstraints[K] extends (infer TConstraint) ? TConstraint extends {
+  readonly kind: 'primary-key' | 'unique';
+  readonly columns: infer TCandidate extends readonly unknown[];
+} ? TColumns extends readonly unknown[] ? SameColumnTuple<TColumns, TCandidate> : false : false : false; }[keyof TConstraints] ? true : false : false;
+type HasMatchingIndex<TColumns, TIndexes> = TIndexes extends SourceIndexesRecord ? true extends { [K in keyof TIndexes]: TIndexes[K] extends (infer TIndex) ? TIndex extends {
+  readonly terms: infer TTerms extends readonly IndexTerm[];
+  readonly candidateKey: infer TCandidateKey;
+} ? [TCandidateKey] extends [true] ? TColumns extends readonly unknown[] ? SameColumnTuple<TColumns, IndexColumns<TTerms>> : false : false : false : false; }[keyof TIndexes] ? true : false : false;
+type TargetMetadata<TTarget extends ForeignKeyTarget, TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = [SourceIdentity<TTarget['table']>] extends [TableIdentity<TName>] ? [TableIdentity<TName>] extends [SourceIdentity<TTarget['table']>] ? readonly [TConstraints, TIndexes] : readonly [ConstraintsOf<TTarget['table']>, IndexesOf<TTarget['table']>] : readonly [ConstraintsOf<TTarget['table']>, IndexesOf<TTarget['table']>];
+type InvalidForeignKey<TConstraint extends ForeignKeyConstraint, TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = ResolvedTarget<TConstraint['target']> extends (infer TTarget) ? TTarget extends ForeignKeyTarget ? Exclude<DependenciesOf<TTarget['columns'][number]>, ColumnDependency<SourceIdentity<TTarget['table']>, string>> extends never ? TargetMetadata<TTarget, TName, TConstraints, TIndexes> extends readonly [infer TTargetConstraints, infer TTargetIndexes] ? HasMatchingConstraint<TTarget['columns'], TTargetConstraints> extends true ? never : HasMatchingIndex<TTarget['columns'], TTargetIndexes> extends true ? never : TConstraint : TConstraint : TConstraint : TConstraint : TConstraint;
+type InvalidConstraint<TConstraint, TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = TConstraint extends ForeignKeyConstraint ? InvalidForeignKey<TConstraint, TName, TConstraints, TIndexes> : TConstraint extends CheckConstraint<infer TExpression> ? InvalidExpression<TExpression, TName> : never;
+type InvalidConstraints<TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = TConstraints[keyof TConstraints] extends (infer TConstraint) ? InvalidConstraint<TConstraint, TName, TConstraints, TIndexes> : never;
+type InvalidIndex<TIndex, TName extends string> = TIndex extends {
+  readonly terms: infer TTerms extends readonly IndexTerm[];
+  readonly predicate: infer TPredicate;
+} ? InvalidExpression<IndexTermExpression<TTerms[number]>, TName> | (TPredicate extends AnyExpression ? SqlTypeOf<TPredicate> extends SqlBoolean ? InvalidExpression<TPredicate, TName> : TPredicate : never) | InvalidIncludedColumns<IndexIncludedColumns<TIndex>, TName> : TIndex;
+type InvalidIndexes<TName extends string, TIndexes extends SourceIndexesRecord> = TIndexes[keyof TIndexes] extends (infer TIndex) ? InvalidIndex<TIndex, TName> : never;
+type ConstraintValidation<TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = [InvalidConstraintDependencies<TName, TConstraints>] extends [never] ? [InvalidConstraints<TName, TConstraints, TIndexes>] extends [never] ? [InvalidIndexes<TName, TIndexes>] extends [never] ? unknown : {
+  readonly __invalid_indexes__: InvalidIndexes<TName, TIndexes>;
+} : {
+  readonly __invalid_constraints__: InvalidConstraints<TName, TConstraints, TIndexes>;
+} : {
+  readonly __invalid_constraint_columns__: InvalidConstraintDependencies<TName, TConstraints>;
+};
+type TableMetadataCallback<TName extends string, TDefinitions extends TableDefinitions, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = (table: Table<TName, TDefinitions>) => TableOptions<TConstraints, TIndexes> & ConstraintValidation<TName, TConstraints, TIndexes>;
+declare function table<const TName extends string, const TDefinitions extends TableDefinitions>(name: TName, definitions: TDefinitions): Table<TName, TDefinitions>;
+declare function table<const TName extends string, const TDefinitions extends TableDefinitions, const TConstraints extends SourceConstraintsRecord, const TIndexes extends SourceIndexesRecord>(name: TName, definitions: TDefinitions, metadata: TableMetadataCallback<TName, TDefinitions, TConstraints, TIndexes>): Table<TName, TDefinitions, TConstraints, TIndexes>;
+//#endregion
+//#region src/schema/source.d.ts
+declare const sourceIdentity: unique symbol;
+type SourceKind = 'table' | 'table-alias' | 'query-alias' | 'lateral' | 'cte' | 'excluded' | 'custom' | 'table-function';
+/** SQL semantic domains keyed by the application fields of a source row. */
+type SourceSqlTypes<TRow extends object> = { readonly [K in keyof TRow]: AnySqlType; };
+/** A source SQL-domain map used when no stronger metadata was declared. */
+type UnknownSourceSqlTypes<TRow extends object> = { readonly [K in keyof TRow]: SqlUnknown; };
+type SourceColumns<TRow extends object, TIdentity, TSqlTypes extends SourceSqlTypes<TRow> = UnknownSourceSqlTypes<TRow>> = { readonly [K in keyof TRow]: K extends string ? ColumnReference<K, ResultMeta<Required<TRow>[K], TIdentity, TSqlTypes[K]> | RequiresSourceMeta<TIdentity> | ExpressionMeta<ColumnDependency<TIdentity, K>>> : never; };
+interface Source<TIdentity = unknown, TRow extends object = Record<string, unknown>, TMetadata = never, TSqlTypes extends SourceSqlTypes<TRow> = UnknownSourceSqlTypes<TRow>, TConstraints extends SourceConstraintsRecord = {}> extends Fragment<ResultMeta<readonly TRow[]> | ProvidesSourceMeta<TIdentity, TRow> | TMetadata> {
+  readonly sourceKind: SourceKind;
+  readonly [sourceIdentity]: TIdentity;
+  readonly reference: Fragment<never>;
+  readonly columns: SourceColumns<TRow, TIdentity, TSqlTypes>;
+  readonly constraints: TConstraints;
+}
+type AnySource = Source<any, any, any, any, any>;
+/** The source-provision fact carried by a source-producing fragment. */
+type SourceProvision<T> = Extract<MetadataOf<T>, {
+  readonly kind: 'provides-source';
+}>;
+type ProvidedSourceIdentity<T> = SourceProvision<T> extends ProvidesSourceMeta<infer TIdentity, any> ? TIdentity : never;
+type ProvidedSourceRow<T> = SourceProvision<T> extends ProvidesSourceMeta<any, infer TRow> ? TRow : never;
+type SourceIdentity<T> = T extends Source<infer TIdentity, any, any, any, any> ? TIdentity : never;
+type SourceRow<T> = T extends Source<any, infer TRow, any, any, any> ? TRow : never;
+/** Extract the field-to-SQL-domain map retained by a source. */
+type SourceSqlTypeMap<T> = T extends {
+  readonly definitions: infer TDefinitions extends TableDefinitions;
+} ? TableSqlTypes<TDefinitions> : T extends Source<any, infer TRow, any, infer TSqlTypes, any> ? TSqlTypes & SourceSqlTypes<TRow> : never;
+/** Structured schema constraints declared for a source. */
+type SourceConstraints<T> = T extends {
+  readonly constraints: infer TConstraints extends SourceConstraintsRecord;
+} ? TConstraints : never;
+interface CustomSourceOptions<TIdentity, TDefinitions extends TableDefinitions> {
+  /** The type-level identity used by columns and source-scope validation. */
+  readonly identity: TIdentity;
+  /** The SQL fragment that renders the relation in FROM or JOIN. */
+  readonly render: RenderFunction;
+  /** The qualified reference used when rendering its columns. */
+  readonly reference: Fragment<never>;
+  /** Output definitions used to build the source's typed columns. */
+  readonly columns: TDefinitions;
+  readonly sourceKind?: SourceKind;
+}
+type CustomSource<TIdentity, TDefinitions extends TableDefinitions> = Source<TIdentity, TableRow<TDefinitions>, never, TableSqlTypes<TDefinitions>> & {
+  readonly identity: TIdentity;
+  readonly definitions: TDefinitions;
+  readonly columns: SourceColumns<TableRow<TDefinitions>, TIdentity, TableSqlTypes<TDefinitions>>;
+} & SourceColumns<TableRow<TDefinitions>, TIdentity, TableSqlTypes<TDefinitions>>;
+declare function createSource<TIdentity, TRow extends object, TMetadata = never, TSqlTypes extends SourceSqlTypes<TRow> = UnknownSourceSqlTypes<TRow>, TConstraints extends SourceConstraintsRecord = {}>(sourceKind: SourceKind, render: RenderFunction, reference: Fragment<never>, constraints?: TConstraints): Source<TIdentity, TRow, TMetadata, TSqlTypes, TConstraints>;
+/**
+ * Create a typed source-producing fragment for a custom FROM relation such as
+ * a table-valued function. The renderer owns the relation syntax and may bind
+ * values through context.parameter(); the source identity and output columns
+ * remain available to the normal FROM/JOIN scope checks.
+ */
+declare function customSource<const TIdentity, const TDefinitions extends TableDefinitions>(options: CustomSourceOptions<TIdentity, TDefinitions>): CustomSource<TIdentity, TDefinitions>;
+/**
+ * Add convenient direct column properties without allowing a column name to
+ * overwrite the source's rendering or metadata primitives.
+ */
+declare function exposeColumns(target: object, columns: Record<string, unknown>): void;
+//#endregion
+//#region src/query/types.d.ts
+type Row = Record<string, unknown>;
+type QueryKind = 'select' | 'set' | 'insert' | 'update' | 'delete';
+interface Query<TRow extends object = Row, TCardinality extends QueryCardinality = QueryCardinality, TMetadata = never, TSqlTypes = SourceSqlTypes<TRow>> extends Fragment<ResultMeta<readonly TRow[]> | CardinalityMeta<TCardinality> | TMetadata> {
+  readonly queryKind: QueryKind;
+  readonly row: TRow;
+  /** Type-only SQL domains of the named query projection. */
+  readonly sqlTypes?: TSqlTypes;
+}
+type AnyQuery = Query<any, any, any, any>;
+type QueryRow<T> = T extends Query<infer TRow, any, any, any> ? TRow : never;
+/** Extract the field-to-SQL-domain map retained by a named query projection. */
+type QuerySqlTypeMap<T> = T extends Query<infer TRow, any, any, infer TSqlTypes> ? TSqlTypes & SourceSqlTypes<TRow> : never;
+//#endregion
+//#region src/core/dialect.d.ts
+/** Capabilities whose syntax must be explicitly supported by a dialect. */
+type DialectCapability = 'ilike' | 'json' | 'on-conflict' | 'row-locking';
+/**
+ * Optional dialect hook used by schema expressions when a JavaScript value
+ * must become SQL text instead of a query parameter.
+ *
+ * The hook is deliberately separate from {@link Dialect.placeholder}: schema
+ * metadata is parameter-free and must never render a query placeholder.
+ */
+type SchemaLiteralRenderer = (value: unknown) => string;
+/** Scalar application types supported by the portable JSON renderer. */
+type JsonScalarKind = 'text' | 'number' | 'boolean';
+/** Dialect policy for portable scalar JSON reads and path existence checks. */
+interface DialectJson {
+  renderScalar(context: RenderContext, document: AnyFragment, path: readonly (string | number)[], kind: JsonScalarKind): void;
+  renderExists(context: RenderContext, document: AnyFragment, path: readonly (string | number)[]): void;
+}
+type PaginationKind = 'offset' | 'fetch';
+/** Logical built-in targets that a dialect can spell in CAST expressions. */
+type PortableCastType = 'integer' | 'decimal' | 'text' | 'boolean' | 'date' | 'timestamp' | 'uuid' | 'json' | 'bigint' | 'binary';
+/** A logical cast target whose concrete spelling is selected by a dialect. */
+interface PortableCastTarget<TType extends PortableCastType = PortableCastType> {
+  readonly kind: 'portable-cast';
+  readonly type: TType;
+}
+/** A trusted raw cast target supplied by a custom definition. */
+interface NamedCastTarget<TTypeName extends string = string> {
+  readonly kind: 'named-cast';
+  readonly typeName: TTypeName;
+}
+/** Runtime target carried by a definition that can be used with cast(). */
+type CastTarget = PortableCastTarget | NamedCastTarget;
+/** Dialect-specific spellings for built-in logical CAST targets. */
+type DialectCastTypes = Readonly<Partial<Record<PortableCastType, string>>>;
+interface PaginationPart {
+  readonly kind: PaginationKind;
+  readonly rows: number;
+  readonly direction?: 'FIRST' | 'NEXT';
+}
+interface DialectPagination {
+  /** Render a complete pagination group in dialect-specific syntax. */
+  readonly render: (context: RenderContext, parts: readonly PaginationPart[]) => void;
+}
+type RowLockMode = 'update' | 'no-key-update' | 'share' | 'key-share';
+type RowLockWaitPolicy = 'default' | 'nowait' | 'skip-locked';
+interface DialectRowLocking {
+  /** Render a dialect-supported row-locking clause. */
+  readonly render: (context: RenderContext, mode: RowLockMode, wait: RowLockWaitPolicy) => void;
+}
+/** Output modes accepted by first-party EXPLAIN policies. */
+type ExplainFormat = 'text' | 'json' | 'xml' | 'yaml' | 'tree' | 'traditional' | 'query-plan' | 'bytecode';
+/** Dialect-independent EXPLAIN switches passed to a dialect policy. */
+interface ExplainRenderOptions {
+  readonly analyze?: boolean;
+  readonly verbose?: boolean;
+  readonly buffers?: boolean;
+  readonly format?: ExplainFormat;
+  /** SQLite's high-level query-plan mode when true, bytecode when false. */
+  readonly queryPlan?: boolean;
+}
+/** Dialect policy for wrapping one rendered query in EXPLAIN syntax. */
+interface DialectExplain {
+  readonly render: (statement: string, queryKind: QueryKind, options: ExplainRenderOptions) => string;
+}
+interface Dialect<TCapabilities extends DialectCapability = DialectCapability> {
+  readonly name: string;
+  quoteIdentifier(identifier: string): string;
+  placeholder(position: number): string;
+  readonly pagination?: DialectPagination;
+  /** Rendering policy for the typed SELECT row-locking clause. */
+  readonly rowLocking?: DialectRowLocking;
+  /** Rendering policy for Qubu's portable JSON operations. */
+  readonly json?: DialectJson;
+  /** Overrides for the standard spelling of logical CAST targets. */
+  readonly castTypes?: DialectCastTypes;
+  /** Optional SQL literal policy used by deterministic schema expressions. */
+  readonly renderSchemaLiteral?: SchemaLiteralRenderer;
+  /** Optional policy for dialect-specific EXPLAIN syntax and options. */
+  readonly explain?: DialectExplain;
+  /** Capabilities advertised by this dialect at the rendering boundary. */
+  readonly capabilities?: readonly TCapabilities[];
+}
+interface DialectOptions<TCapabilities extends Exclude<DialectCapability, 'json'> = never, TJson extends DialectJson | undefined = DialectJson | undefined> {
+  readonly name: string;
+  readonly quoteIdentifier?: (identifier: string) => string;
+  readonly placeholder: (position: number) => string;
+  readonly pagination?: DialectPagination;
+  /** Rendering policy for the typed SELECT row-locking clause. */
+  readonly rowLocking?: DialectRowLocking;
+  readonly json?: TJson;
+  /** Overrides for the standard spelling of logical CAST targets. */
+  readonly castTypes?: DialectCastTypes;
+  /** Optional SQL literal policy used by deterministic schema expressions. */
+  readonly renderSchemaLiteral?: SchemaLiteralRenderer;
+  /** Optional policy for dialect-specific EXPLAIN syntax and options. */
+  readonly explain?: DialectExplain;
+  readonly capabilities?: readonly TCapabilities[];
+}
+/** Resolve a logical or explicitly named CAST target for a dialect. */
+declare function resolveCastTarget(dialect: Dialect, target: CastTarget): string;
+/**
+ * Create a dialect from the few rendering decisions that SQL builders need
+ * to leave open. More involved syntax can be supplied as a custom fragment.
+ */
+declare function createDialect<const TCapabilities extends Exclude<DialectCapability, 'json'> = never>(options: DialectOptions<TCapabilities, DialectJson> & {
+  readonly json: DialectJson;
+}): Dialect<TCapabilities | 'json'>;
+declare function createDialect<const TCapabilities extends Exclude<DialectCapability, 'json'> = never>(options: DialectOptions<TCapabilities, undefined>): Dialect<TCapabilities>;
+/**
+ * Check a capability at runtime for callers that intentionally bypass the
+ * typed render boundary or use a dialect supplied by an older integration.
+ */
+declare function assertDialectCapability(dialect: Dialect, capability: DialectCapability): void;
+//#endregion
+//#region src/snapshot/types.d.ts
+/** The JSON object tag used by Qubu schema snapshots. */
+declare const schemaSnapshotFormat: "qubu-schema";
+/** The first canonical schema snapshot format version. */
+declare const schemaSnapshotVersion: 1;
+/** The first version of the dialect-extension envelope. */
+declare const schemaSnapshotDialectVersion: 1;
+/** The first version of the built-in naming-policy description. */
+declare const schemaSnapshotNamingPolicyVersion: 1;
+/** The neutral dialect used when no SQL engine adapter is selected. */
+declare const neutralSnapshotDialect: SnapshotDialect;
+/** A dialect identifier and independently versioned extension contract. */
+interface SnapshotDialect {
+  readonly name: string;
+  readonly version: number;
+}
+/** Naming-policy identity retained by a snapshot, without executable code. */
+interface SnapshotNamingPolicy {
+  readonly name: string;
+  readonly version: number;
+}
+/** A JSON-safe representation of a non-finite JavaScript number. */
+interface SnapshotSpecialNumber {
+  readonly $number: 'NaN' | 'Infinity' | '-Infinity';
+}
+/** A JSON-safe representation of a JavaScript bigint. */
+interface SnapshotBigInt {
+  readonly $bigint: string;
+}
+/** Values accepted inside versioned dialect extension data. */
+type SnapshotJsonValue = null | boolean | string | number | SnapshotSpecialNumber | SnapshotBigInt | readonly SnapshotJsonValue[] | {
+  readonly [key: string]: SnapshotJsonValue;
+};
+/** A dialect-owned payload kept separate from portable schema facts. */
+interface SnapshotDialectExtension {
+  readonly dialect: string;
+  readonly version: number;
+  readonly data: SnapshotJsonValue;
+}
+/** A portable or dialect-owned physical column declaration. */
+type SnapshotStorage = {
+  readonly kind: 'portable';
+  readonly type: string;
+} | {
+  readonly kind: 'native';
+  readonly dialect: string;
+  readonly type: string;
+  /** SQLite's derived type affinity, when the selected adapter records it. */
+  readonly affinity?: 'blob' | 'integer' | 'numeric' | 'real' | 'text';
+};
+/** A deterministic expression after it crosses the snapshot data boundary. */
+interface SnapshotExpression {
+  readonly kind: 'expression';
+  readonly expressionKind: string;
+  /** Canonical parameter-free text for the selected schema expression dialect. */
+  readonly sql: string;
+  /** Present only for an explicitly dialect-tagged unsafe expression. */
+  readonly dialect?: string;
+}
+/** A default value retained independently from insert-write behavior. */
+type SnapshotDefault = {
+  readonly kind: 'literal';
+  readonly value: SnapshotLiteral;
+} | {
+  readonly kind: 'expression';
+  readonly expression: SnapshotExpression;
+} | {
+  readonly kind: 'external';
+};
+/** Canonical literal values accepted by neutral schema metadata. */
+type SnapshotLiteral = {
+  readonly kind: 'null';
+} | {
+  readonly kind: 'boolean';
+  readonly value: boolean;
+} | {
+  readonly kind: 'string';
+  readonly value: string;
+} | {
+  readonly kind: 'number';
+  readonly value: string;
+} | {
+  readonly kind: 'bigint';
+  readonly value: string;
+};
+/** A generated-column expression and its storage mode. */
+type SnapshotGeneratedColumn = {
+  readonly kind: 'expression';
+  readonly expression: SnapshotExpression;
+  readonly mode: 'stored' | 'virtual';
+} | {
+  readonly kind: 'external';
+};
+/** Identity behavior is deliberately separate from generated expressions. */
+interface SnapshotIdentity {
+  readonly kind: 'identity';
+  readonly generation: 'always' | 'by-default';
+  readonly dialect?: SnapshotDialectExtension;
+}
+/** A canonical column record keyed by its stable logical field ID. */
+interface SnapshotColumn {
+  readonly id: string;
+  readonly physicalName: string;
+  readonly nullable: boolean;
+  readonly hasDefault: boolean;
+  readonly generated: boolean;
+  readonly storage?: SnapshotStorage;
+  readonly default?: SnapshotDefault;
+  readonly generatedColumn?: SnapshotGeneratedColumn;
+  readonly identity?: SnapshotIdentity;
+  /** MySQL's parameter-free column update expression, when supported. */
+  readonly onUpdate?: SnapshotExpression;
+}
+/** An expression or bare column used by an index. */
+type SnapshotIndexTermExpression = {
+  readonly kind: 'column';
+  readonly column: string;
+} | {
+  readonly kind: 'expression';
+  readonly expression: SnapshotExpression;
+};
+/** One ordered index term. */
+type SnapshotIndexTerm = SnapshotIndexTermExpression | {
+  readonly kind: 'order';
+  readonly expression: SnapshotIndexTermExpression;
+  readonly direction?: 'ASC' | 'DESC';
+  readonly nulls?: 'FIRST' | 'LAST';
+};
+/** Common key metadata shared by primary and strict unique constraints. */
+interface SnapshotKeyConstraint {
+  readonly id: string;
+  readonly kind: 'primary-key' | 'unique';
+  readonly physicalName: string;
+  readonly columns: readonly string[];
+  readonly deferrable?: boolean;
+  readonly initially?: 'immediate' | 'deferred';
+  readonly dialect?: SnapshotDialectExtension;
+}
+/** Nullable database uniqueness, intentionally not a candidate-key proof. */
+interface SnapshotUniqueConstraint {
+  readonly id: string;
+  readonly kind: 'unique-constraint';
+  readonly physicalName: string;
+  readonly columns: readonly string[];
+  readonly nulls: 'distinct' | 'not-distinct';
+  readonly deferrable?: boolean;
+  readonly initially?: 'immediate' | 'deferred';
+  readonly dialect?: SnapshotDialectExtension;
+}
+/** A foreign key whose target is represented only by logical IDs. */
+interface SnapshotForeignKey {
+  readonly id: string;
+  readonly kind: 'foreign-key';
+  readonly physicalName: string;
+  readonly columns: readonly string[];
+  readonly target: {
+    readonly table: string;
+    readonly columns: readonly string[];
+  };
+  readonly onUpdate?: 'no-action' | 'restrict' | 'cascade' | 'set-null' | 'set-default';
+  readonly onDelete?: 'no-action' | 'restrict' | 'cascade' | 'set-null' | 'set-default';
+  readonly match?: 'simple' | 'full' | 'partial';
+  readonly deferrable?: boolean;
+  readonly initially?: 'immediate' | 'deferred';
+  readonly dialect?: SnapshotDialectExtension;
+}
+/** A table check constraint with a detached expression value. */
+interface SnapshotCheckConstraint {
+  readonly id: string;
+  readonly kind: 'check';
+  readonly physicalName: string;
+  readonly expression: SnapshotExpression;
+  readonly deferrable?: boolean;
+  readonly initially?: 'immediate' | 'deferred';
+  readonly dialect?: SnapshotDialectExtension;
+}
+/** Every constraint represented by the v1 neutral model. */
+type SnapshotConstraint = SnapshotKeyConstraint | SnapshotUniqueConstraint | SnapshotForeignKey | SnapshotCheckConstraint;
+/** A canonical index record keyed by its stable logical ID. */
+interface SnapshotIndex {
+  readonly id: string;
+  readonly kind: 'index';
+  readonly physicalName: string;
+  readonly terms: readonly SnapshotIndexTerm[];
+  readonly unique: boolean;
+  readonly candidateKey: boolean;
+  readonly predicate?: SnapshotExpression;
+  readonly includedColumns?: readonly string[];
+  readonly dialect?: SnapshotDialectExtension;
+}
+/** A table record keyed by its stable logical registry ID. */
+interface SnapshotTable {
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly SnapshotColumn[];
+  readonly constraints: readonly SnapshotConstraint[];
+  readonly indexes: readonly SnapshotIndex[];
+}
+/** The immutable canonical schema snapshot envelope. */
+interface SchemaSnapshot {
+  readonly format: typeof schemaSnapshotFormat;
+  readonly version: typeof schemaSnapshotVersion;
+  readonly dialect: SnapshotDialect;
+  readonly namingPolicy: SnapshotNamingPolicy;
+  readonly namespace?: string;
+  readonly tables: readonly SnapshotTable[];
+}
+/** Schema-expression context supplied to a dialect adapter. */
+interface SnapshotExpressionContext {
+  readonly mode: 'default' | 'generated' | 'check' | 'index';
+  readonly path: readonly (string | number)[];
+  readonly dialect: SchemaDialect;
+}
+/** Storage context supplied to a dialect adapter. */
+interface SnapshotStorageContext {
+  readonly path: readonly (string | number)[];
+  readonly dialect: SchemaDialect;
+}
+/** Extension context supplied to a dialect adapter. */
+interface SnapshotExtensionContext {
+  readonly path: readonly (string | number)[];
+  readonly dialect: SchemaDialect;
+}
+/** Context supplied to an adapter's dialect-capability validation hook. */
+interface SnapshotValidationContext {
+  readonly path: readonly (string | number)[];
+  readonly dialect: SchemaDialect;
+}
+/**
+ * Adapter boundary for the common traversal. Schema hooks live on
+ * `dialect.schema`; the adapter only selects that schema dialect, so
+ * PostgreSQL, SQLite, and MySQL can share the query rendering policy without
+ * taking ownership of canonical ordering or cross-reference validation.
+ */
+interface SchemaSnapshotAdapter<TCapabilities extends DialectCapability = DialectCapability> {
+  /** The query dialect plus its schema hooks and metadata. */
+  readonly dialect: SchemaDialect<TCapabilities>;
+}
+/** Structured diagnostic categories emitted by snapshot tooling. */
+type SnapshotDiagnosticCode = 'invalid-schema' | 'invalid-value' | 'unsupported-expression' | 'dialect-mismatch' | 'unresolved-reference' | 'invalid-snapshot' | 'unknown-field' | 'future-version' | 'invalid-cross-reference' | 'non-canonical' | 'unsupported-dialect-option';
+/** A path-addressed snapshot diagnostic suitable for CLI or editor output. */
+interface SnapshotDiagnostic {
+  readonly code: SnapshotDiagnosticCode;
+  readonly message: string;
+  readonly path: readonly (string | number)[];
+  readonly relatedPaths?: readonly (readonly (string | number)[])[];
+}
+/** Result returned by the strict snapshot decoder. */
+type SnapshotDecodeResult = {
+  readonly ok: true;
+  readonly value: SchemaSnapshot;
+} | {
+  readonly ok: false;
+  readonly diagnostics: readonly SnapshotDiagnostic[];
+};
+/** Result returned by a non-throwing schema traversal helper. */
+type SnapshotCreateResult = {
+  readonly ok: true;
+  readonly value: SchemaSnapshot;
+} | {
+  readonly ok: false;
+  readonly diagnostics: readonly SnapshotDiagnostic[];
+};
+/** A schema snapshot input accepted by the canonical encoder. */
+type SchemaSnapshotInput = SchemaSnapshot | Readonly<Record<string, unknown>>;
+/** Expose the schema generic in tooling declarations without widening APIs. */
+type AnySchema = Schema<any>;
+//#endregion
+export { PaginationKind as $, ExplainReadOptions as $a, ColumnReference as $c, lower as $i, SubqueryMeta as $l, RequiredOuterScope as $n, SourceConstraint as $o, SchemaOptions as $r, boolean as $s, SqliteIndexExtension as $t, SnapshotStorage as A, between as Aa, ResolvedColumnBehavior as Ac, offset as Ai, HasSubquery as Al, UpdateAssignments as An, QueryValidationError as Ao, SelectionSqlTypes as Ar, ColumnStorageDeclarationOf as As, createSource as At, CastTarget as B, asValue as Ba, SchemaDialectName as Bc, subtract as Bi, ProvidesOuterSourceMeta as Bl, MutationSqlTypes as Bn, ConstraintTiming as Bo, SchemaRenderContext as Br, NativeStorage as Bs, TableMetadataCallback as Bt, SnapshotIndexTerm as C, isDistinctFrom as Ca, GeneratedColumnMode as Cc, omit as Ci, ExpressionMeta as Cl, ExcludedSource as Cn, qubu as Co, leftJoin as Cr, ColumnIsGenerated as Cs, SourceIdentity as Ct, SqlTypeSatisfies as Cu, SnapshotLiteral as D, lte as Da, IdentityGeneration as Dc, rowLock as Di, GroupingKeysOf as Dl, excluded as Dn, RenderedQuery as Do, Selection as Dr, ColumnOutput as Ds, SourceSqlTypeMap as Dt, SnapshotKeyConstraint as E, lt as Ea, IdentityDialectExtension as Ec, RowLockOptions as Ei, GroupingDependenciesOf as El, doUpdate as En, RenderOptions as Eo, groupBy as Er, ColumnOptions as Es, SourceRow as Et, neutralSnapshotDialect as F, isTrue as Fa, externalGeneratedColumn as Fc, SelectClause as Fi, NullabilityOf as Fl, MutationQuery as Fn, CatalogCheckSql as Fo, RenderedSchemaExpression as Fr, ColumnStorageType as Fs, Table as Ft, DialectJson as G, DriverValueEncoder as Ga, assertSchemaDialectSupport as Gc, jsonPath as Gi, RequiresCapabilityMeta as Gl, returning as Gn, ForeignKeyOptions as Go, normalizeSchemaSql as Gr, PortableStorageType as Gs, table as Gt, DialectCapability as H, value as Ha, SchemaMetadataValidationError as Hc, jsonBoolean as Hi, QueryCardinality as Hl, ReturningClause as Hn, FieldLikeOptions as Ho, UnsafeSchemaSqlExpression as Hr, PortableColumnStorage as Hs, TableRow as Ht, schemaSnapshotDialectVersion as I, Operand as Ia, generatedColumn as Ic, add as Ii, NullableSourceMeta as Il, MutationReturning as In, CheckConstraint as Io, SchemaExpressionError as Ir, ColumnStorageTypeOf as Is, TableColumns as It, DialectRowLocking as J, ExecutionResult as Ja, generatedSchemaObjectName as Jc, over as Ji, RequiresOuterOf as Jl, AvailableOuterScope as Jn, KeyConstraint as Jo, schemaExpression as Jr, StorageDialectOf as Js, IndexTerm as Jt, DialectOptions as K, ExecutionOptions as Ka, dialectMismatchDiagnostic as Kc, jsonText as Ki, RequiresOf as Kl, correlate as Kn, ForeignKeyTarget as Ko, renderSchemaExpression as Kr, StorageDeclarationOf as Ks, IndexDialectExtension as Kt, schemaSnapshotFormat as L, OperandNullability as La, identityColumn as Lc, divide as Li, NullableSourcesOf as Ll, MutationReturningClause as Ln, CheckConstraintOptions as Lo, SchemaExpressionErrorCode as Lr, ColumnUpdateInput as Ls, TableDefinitions as Lt, SnapshotTable as M, notIn as Ma, SqliteIdentityExtension as Mc, distinct as Mi, InheritedMetadata as Ml, AllowAllClause as Mn, QueryValidationIssue as Mo, SchemaDialect as Mr, ColumnStorageDialectOf as Ms, exposeColumns as Mt, SnapshotUniqueConstraint as N, isNotNull as Na, canonicalLiteral as Nc, AnySelectClause as Ni, InheritedMetadataOf as Nl, MutationClause as Nn, AnyKeyColumn as No, SchemaDialectHooks as Nr, ColumnStorageKindOf as Ns, sourceIdentity as Nt, SnapshotNamingPolicy as O, ne as Oa, LiteralDefaultDescriptor as Oc, fetchFirst as Oi, GroupingMeta as Ol, onConflict as On, render as Oo, SelectionObject as Or, ColumnSqlType as Os, SourceSqlTypes as Ot, SnapshotValidationContext as P, isNull as Pa, externalDefault as Pc, ClausePlacement as Pi, MetadataOf as Pl, MutationKind as Pn, CatalogCheckExpression as Po, createSchemaDialect as Pr, ColumnStorageOf as Ps, AnyTable as Pt, NamedCastTarget as Q, ExplainPlanRow as Qa, ColumnDependency as Qc, concat as Qi, SqlTypeOf as Ql, MissingScope as Qn, ReferentialAction as Qo, SchemaNamingPolicy as Qr, binary as Qs, SourceIndexesRecord as Qt, schemaSnapshotNamingPolicyVersion as R, OperandSqlType as Ra, resolveColumnBehavior as Rc, modulo as Ri, OutputOf as Rl, MutationRow as Rn, ConstraintDialectExtension as Ro, SchemaExpressionInput as Rr, DialectNativeStorage as Rs, TableIdentity as Rt, SnapshotIndex as S, gte as Sa, GeneratedColumnDescriptor as Sc, SelectPart as Si, DependenciesOf as Sl, DoUpdateAction as Sn, explain as So, innerJoin as Sr, ColumnInsertInput as Ss, SourceConstraints as St, SqlTimestamp as Su, SnapshotJsonValue as T, like as Ta, IdentityDescriptor as Tc, RowLockClause as Ti, FragmentMeta as Tl, doNothing as Tn, RenderCapabilityValidation as To, rightJoin as Tr, ColumnOnUpdateOf as Ts, SourceProvision as Tt, SqlUuid as Tu, DialectCastTypes as U, cast as Ua, SchemaObjectIdentity as Uc, jsonExists as Ui, RenderContext as Ul, ReturningRow as Un, ForeignKeyConstraint as Uo, defineSchemaExpression as Ur, PortableStorage as Us, TableSqlTypes as Ut, Dialect as V, typedValue as Va, SchemaMetadataDiagnostic as Vc, JsonPath as Vi, ProvidesSourceMeta as Vl, allowAll as Vn, FieldLike as Vo, SchemaRenderOptions as Vr, NativeStorageDescriptor as Vs, TableOptions as Vt, DialectExplain as W, typedCast as Wa, SchemaObjectNameOptions as Wc, jsonNumber as Wi, RenderFunction as Wl, ReturningSqlTypes as Wn, ForeignKeyMatch as Wo, isUnsafeSchemaSql as Wr, PortableStorageDescriptor as Ws, TableUpdateInput as Wt, ExplainRenderOptions as X, ExplainOptions as Xa, materializeSchemaObjectIdentity as Xc, rowNumber as Xi, RequiresSourceMeta as Xl, ClauseScope as Xn, MysqlConstraintExtension as Xo, Schema as Xr, StorageTypeOf as Xs, PostgresIndexExtension as Xt, ExplainFormat as Y, ExplainMutationOptions as Ya, isValidSchemaObjectName as Yc, rank as Yi, RequiresOuterSourceMeta as Yl, AvailableScope as Yn, KeyConstraintOptions as Yo, unsafeSchemaSql as Yr, StorageOf as Ys, MysqlIndexExtension as Yt, JsonScalarKind as Z, ExplainOptionsFor as Za, materializeSchemaObjectRecord as Zc, coalesce as Zi, ResultMeta as Zl, GroupingValidation as Zn, PostgresConstraintExtension as Zo, SchemaDiagnostic as Zr, bigint as Zs, SourceIndex as Zt, SnapshotExpressionContext as _, notExists as _a, DefaultDescriptor as _c, and as _i, AnyFragment as _l, insertSelect as _n, StreamingTransactionalQueryAdapter as _o, FromScope as _r, ColumnDefinition as _s, CustomSourceOptions as _t, SqlOrderCompatible as _u, SnapshotBigInt as a, count as aa, nativeStorage as ac, defaultSchemaNamingPolicy as ai, ExpressionNullability as al, desc as an, QubuExplainableStreamingTransactionalClient as ao, RecursiveCteSource as ar, UniqueConstraintOptions as as, SchemaLiteralRenderer as at, sequence as au, SnapshotGeneratedColumn as b, eq as ba, ExternalDefaultDescriptor as bc, Omit$1 as bi, CardinalityMeta as bl, ConflictTarget as bn, execute as bo, crossJoin as br, ColumnHasDefault as bs, Source as bt, SqlText as bu, SnapshotConstraint as c, min as ca, portableStorage as cc, schemaNamingPolicyVersion as ci, ExpressionSqlType as cl, order as cn, QubuStreamingExplainableClient as co, recursiveCte as cr, catalogForeignKey as cs, resolveCastTarget as ct, SqlBinary as cu, SnapshotDefault as d, SqlTag as da, uuid as dc, LateralIdentity as di, isExpression as dl, DefaultValuesSource as dn, QubuTransaction as do, SetQuery as dr, primaryKey as ds, QueryKind as dt, SqlDecimal as du, upper as ea, column as ec, SchemaTableEntry as ei, expressionFragment as el, TableIndex as en, ExplainRequest as eo, RequiredScope as er, SourceConstraintsRecord as es, PaginationPart as et, VisibleDependenciesOf as eu, SnapshotDiagnostic as f, TypedSqlTag as fa, CanonicalLiteral as fc, LateralSource as fi, makeExpression as fl, InsertSelectSource as fn, QubuTransactionalClient as fo, except as fr, references as fs, QueryRow as ft, SqlEqualityComparable as fu, SnapshotExpression as g, inQuery as ga, ColumnDefaultInput as gc, lateral as gi, AggregateMeta as gl, insertInto as gn, StreamingQueryAdapter as go, FromClause as gr, ColumnDefaultOf as gs, CustomSource as gt, SqlNumericLike as gu, SnapshotDialectExtension as h, exists as ha, ColumnDefault as hc, alias as hi, AggregateDependenciesOf as hl, defaultValues as hn, StreamableQuery as ho, unionAll as hr, validateConstraintDialect as hs, AnySource as ht, SqlJson as hu, SchemaSnapshotInput as i, avg as ia, nativeColumn as ic, SchemaValidationError as ii, ExpressionKind as il, asc as in, QubuExplainableClient as io, CteSource as ir, UniqueConstraint as is, RowLockWaitPolicy as it, parenthesize as iu, SnapshotStorageContext as j, inList as ja, SchemaLiteralValue as jc, having as ji, HasWindow as jl, update as jn, QueryValidationErrorCode as jo, all as jr, ColumnStorageDescriptor as js, customSource as jt, SnapshotSpecialNumber as k, notLike as ka, MysqlIdentityExtension as kc, fetchNext as ki, HasAggregate as kl, UpdateAssignmentValue as kn, QueryTypeValidation as ko, SelectionOutput as kr, ColumnStorage as ks, UnknownSourceSqlTypes as kt, SnapshotCreateResult as l, sum as la, text as lc, AliasIdentity as li, ExpressionWithOutput as ll, orderBy as ln, QubuStreamingTransaction as lo, withCte as lr, check as ls, AnyQuery as lt, SqlBoolean as lu, SnapshotDialect as m, caseWhen as ma, ColumnBehaviorErrorCode as mc, QuerySource as mi, withDialectCapability as ml, ValuesSource as mn, QueryExecutor as mo, union as mr, uniqueConstraint as ms, Row as mt, SqlInteger as mu, SchemaSnapshot as n, schemaCall as na, integer as nc, SchemaTableRecord as ni, AnySchemaExpression as nl, validateIndexDialect as nn, ExplainableQueryAdapter as no, SelectCardinality as nr, SqliteConstraintExtension as ns, PortableCastType as nt, fragment as nu, SnapshotCheckConstraint as o, countDistinct as oa, nullable as oc, generatedTableName as oi, ExpressionOutput as ol, nullsFirst as on, QubuExplainableTransactionalClient as oo, WithClause as or, UniqueNullSemantics as os, assertDialectCapability as ot, AnySqlType as ou, SnapshotDiagnosticCode as p, sql as pa, ColumnBehaviorError as pc, QueryAliasIdentity as pi, markExpressionCategory as pl, InsertSource as pn, QueryAdapter as po, intersect as pr, unique as ps, QuerySqlTypeMap as pt, SqlEqualityCompatible as pu, DialectPagination as q, ExecutionRequest as qa, freezeSchemaMetadata as qc, denseRank as qi, RequiresOuterMetadataOf as ql, select as qn, ForeignKeyTargetInput as qo, renderSchemaSql as qr, StorageDescriptor as qs, IndexOptions as qt, SchemaSnapshotAdapter as r, typedCall as ra, json as rc, SchemaTableRegistry as ri, Expression as rl, OrderTerm as rn, QubuClient as ro, SelectQuery as rr, TableLike as rs, RowLockMode as rt, isFragment as ru, SnapshotColumn as s, max as sa, numeric as sc, schema as si, ExpressionRequires as sl, nullsLast as sn, QubuStreamingClient as so, cte as sr, catalogCheck as ss, createDialect as st, SqlBigInt as su, AnySchema as t, call as ta, date as tc, SchemaTableNames as ti, AnyExpression as tl, index as tn, ExplainResult as to, ScopeValidation as tr, SourceLike as ts, PortableCastTarget as tt, WindowMeta as tu, SnapshotDecodeResult as u, SqlFragment as ua, timestamp as uc, AliasedSource as ui, SchemaExpression as ul, deleteFrom as un, QubuStreamingTransactionalClient as uo, SetOperator as ur, foreignKey as us, Query as ut, SqlDate as uu, SnapshotExtensionContext as v, scalar as va, ExpressionDefaultDescriptor as vc, not as vi, CapabilitiesOf as vl, values as vn, TransactionOptions as vo, FromSource as vr, ColumnFromOptions as vs, ProvidedSourceIdentity as vt, SqlOrderable as vu, SnapshotIndexTermExpression as w, isNotDistinctFrom as wa, GeneratedDescriptor as wc, where as wi, Fragment as wl, OnConflictClause as wn, stream as wo, naturalJoin as wr, ColumnIsNullable as ws, SourceKind as wt, SqlUnknown as wu, SnapshotIdentity as x, gt as xa, ExternalGeneratedColumnDescriptor as xc, OmittableSelectClause as xi, CardinalityOf as xl, DoNothingAction as xn, executeRows as xo, fullJoin as xr, ColumnIdentityOf as xs, SourceColumns as xt, SqlTextLike as xu, SnapshotForeignKey as y, ComparisonValidation as ya, ExpressionGeneratedColumnDescriptor as yc, or as yi, CapabilityMetadataOf as yl, ConflictAction as yn, TransactionalQueryAdapter as yo, from as yr, ColumnGeneratedOf as ys, ProvidedSourceRow as yt, SqlSemanticType as yu, schemaSnapshotVersion as z, SqlCapabilityValidation as za, SchemaDialectExtension as zc, multiply as zi, ProvidesOuterOf as zl, MutationScopeValidation as zn, ConstraintOptions as zo, SchemaExpressionMode as zr, NativeColumnStorage as zs, TableInsertInput as zt };