qubu 0.6.0 → 0.6.2

package/dist/{types-C0VkiwpR.d.mts → types-Dqr4o2I1.d.mts}

@@ -50,6 +50,8 @@ type SqlBigInt = SqlSemanticType<"bigint"> & SqlNumericLike & SqlOrderable<"nume
 type SqlBinary = SqlSemanticType<"binary"> & SqlEqualityComparable<"binary">;
 /** Any declared SQL semantic type, including user and dialect extensions. */
 type AnySqlType = SqlSemanticType<string>;
+/** Runtime name for a SQL semantic domain, including user and dialect extensions. */
+type SqlTypeName = AnySqlType["sqlType"];
 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;
@@ -123,7 +125,7 @@ type CardinalityMeta<TCardinality extends QueryCardinality = QueryCardinality> =
   readonly cardinality: TCardinality;
 };
 /** A fragment whose syntax must be rendered by a dialect with this capability. */
-type RequiresCapabilityMeta<TCapability extends DialectCapability = DialectCapability> = {
+type RequiresCapabilityMeta<TCapability extends string = DialectCapability> = {
   readonly kind: "requires-capability";
   readonly capability: TCapability;
 };
@@ -133,7 +135,8 @@ interface RenderContext {
   /** Whether selected fields name an application result or a SQL relation. */
   readonly projectionMode: "result" | "relation";
   append(text: string): void;
-  parameter(value: unknown): void;
+  /** Add one ordered parameter, optionally declaring its runtime SQL domain. */
+  parameter(value: unknown, sqlType?: SqlTypeName): void;
   render(part: Fragment<any>): void;
   /** Render an embedded query with SQL-facing projection names. */
   renderRelation(part: Fragment<any>): void;
@@ -208,7 +211,7 @@ type Cardinality<TMetadata> = TMetadata extends {
 } ? TCardinality : never;
 type RequiredCapabilities<TMetadata> = TMetadata extends {
   readonly kind: "requires-capability";
-  readonly capability: infer TCapability extends DialectCapability;
+  readonly capability: infer TCapability extends string;
 } ? TCapability : never;
 type InheritedMetadataOf<TMetadata> = WithoutResult<TMetadata>;
 type InheritedMetadata<T> = InheritedMetadataOf<MetadataOf<T>>;
@@ -248,7 +251,7 @@ declare function isFragment(value: unknown): value is AnyFragment;
 //#endregion
 //#region src/result.d.ts
 /** Portable result domains that can require driver-specific normalization. */
-type DecodableResultType = "boolean" | "date" | "timestamp" | "json";
+type DecodableResultType = "boolean" | "date" | "timestamp" | "json" | "bigint";
 /** Context supplied while decoding one projected field. */
 interface ResultDecodeContext {
   readonly dialect: Dialect;
@@ -264,6 +267,8 @@ interface ResultField {
   readonly name: string;
   readonly type?: DecodableResultType;
   readonly decoder?: ResultDecoder;
+  /** SQL semantic domain supplied to the adapter before it executes the request. */
+  readonly sqlType?: SqlTypeName;
 }
 /** Runtime description of a query's named result row. */
 interface ResultShape {
@@ -272,11 +277,14 @@ interface ResultShape {
 interface ResultValueMetadata {
   readonly type?: DecodableResultType;
   readonly decoder?: ResultDecoder;
+  /** SQL semantic domain retained for adapter-specific result handling. */
+  readonly sqlType?: SqlTypeName;
 }
 declare const resultValueMetadata: unique symbol;
 type ResultValueCarrier = {
   readonly [resultValueMetadata]?: ResultValueMetadata;
 };
+declare function resultValue(type?: DecodableResultType, decoder?: ResultDecoder, sqlType?: SqlTypeName): ResultValueMetadata | undefined;
 /** Decode SQLite/MySQL-style boolean values while accepting native booleans. */
 declare const booleanResultDecoder: ResultDecoder<boolean>;
 /** Decode a SQL DATE string as a JavaScript Date at UTC midnight. */
@@ -285,6 +293,8 @@ declare const dateResultDecoder: ResultDecoder<Date>;
 declare const timestampResultDecoder: ResultDecoder<Date>;
 /** Decode a serialized JSON result. Use only when the adapter returns JSON text. */
 declare const jsonTextResultDecoder: ResultDecoder;
+/** Decode an exact integer result without ever accepting an unsafe JavaScript number. */
+declare const bigintResultDecoder: ResultDecoder<bigint>;
 /** Error raised when a projected driver value cannot be decoded. */
 declare class ResultDecodingError extends TypeError {
   readonly name = "ResultDecodingError";
@@ -319,7 +329,7 @@ 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"]>;
+declare function withDialectCapability<const TCapability extends string, 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>;
 /** Sparse type-level configuration for a result-producing expression. */
@@ -401,15 +411,17 @@ type DefaultDialectCapability = "json";
 interface RenderedQuery {
   readonly text: string;
   readonly parameters: readonly unknown[];
+  /** Runtime SQL domains aligned with `parameters`; omitted when all domains are unknown. */
+  readonly parameterSqlTypes?: readonly (SqlTypeName | undefined)[];
 }
-interface RenderOptions<TCapabilities extends DialectCapability = DialectCapability> {
+interface RenderOptions<TCapabilities extends string = string> {
   readonly dialect?: Dialect<TCapabilities>;
 }
 type IsAny$1<T> = 0 extends 1 & T ? true : false;
-type MissingCapabilities<TQuery, TCapabilities extends DialectCapability> = IsAny$1<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>>;
+type MissingCapabilities<TQuery, TCapabilities extends string> = IsAny$1<CapabilitiesOf<TQuery>> extends true ? never : Exclude<CapabilitiesOf<TQuery>, TCapabilities>;
+type RenderCapabilityValidation<TQuery, TCapabilities extends string> = [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;
+declare function render<TQuery extends AnyFragment, TCapabilities extends string>(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>> = QueryWithRow<TRow> & {
@@ -506,9 +518,9 @@ interface QubuHooks {
 interface QubuOptions {
   readonly hooks?: QubuHooks;
 }
-/** One rendered statement and the controls passed to an application adapter. */
+/** One rendered statement, runtime parameter domains, and controls passed to an application adapter. */
 interface ExecutionRequest {
-  /** SQL text and raw application parameters produced by Qubu's renderer. */
+  /** SQL text, raw application parameters, and optional domain sidecar produced by Qubu's renderer. */
   readonly statement: RenderedQuery;
   /** The source query kind, available without parsing rendered SQL. */
   readonly queryKind: QueryKind;
@@ -550,9 +562,10 @@ interface ExplainResult<TPlanRow extends object = Record<string, unknown>> {
 }
 /**
  * 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 proprietary driver-row normalization remain adapter concerns. Qubu
- * applies the adapter's registered logical result decoders afterward.
+ * placeholder order, and `request.statement.parameterSqlTypes` optionally contains their aligned
+ * SQL domains. The adapter binds and encodes them for its driver. Connection pooling, transactions,
+ * retries, and proprietary driver-row normalization remain adapter concerns. Qubu applies the
+ * adapter's registered logical result decoders afterward.
  */
 interface QueryAdapter {
   /** Default rendering policy for queries sent through this adapter. */
@@ -594,6 +607,8 @@ type QueryExecutor = QueryAdapter;
 interface TransactionalQueryAdapter<TTransactionAdapter extends QueryAdapter = QueryAdapter> extends QueryAdapter {
   transaction<T>(callback: (adapter: TTransactionAdapter) => Promise<T>, options?: TransactionOptions): Promise<T>;
 }
+/** Opt-in recursive transaction scopes; adapters own savepoints and scope lifetime. */
+interface NestedTransactionalQueryAdapter<TBase extends QueryAdapter = QueryAdapter> extends TransactionalQueryAdapter<TBase & NestedTransactionalQueryAdapter<TBase>> {}
 type TransactionAdapterOf<TAdapter extends TransactionalQueryAdapter> = TAdapter extends TransactionalQueryAdapter<infer TTransactionAdapter> ? TTransactionAdapter : never;
 /** A transaction-capable streaming adapter whose scoped client can stream. */
 type StreamingTransactionalQueryAdapter = StreamingQueryAdapter & TransactionalQueryAdapter<StreamingQueryAdapter>;
@@ -618,7 +633,8 @@ interface QubuStreamingClient<TAdapter extends StreamingQueryAdapter = Streaming
 }
 /** 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>;
+type QubuBaseClientFor<TAdapter extends QueryAdapter> = TAdapter extends StreamingQueryAdapter ? TAdapter extends ExplainableQueryAdapter ? QubuStreamingExplainableClient<TAdapter> : QubuStreamingClient<TAdapter> : TAdapter extends ExplainableQueryAdapter ? QubuExplainableClient<TAdapter> : QubuClient<TAdapter>;
+type QubuClientFor<TAdapter extends QueryAdapter> = QubuBaseClientFor<TAdapter> & (TAdapter extends TransactionalQueryAdapter ? QubuTransactionalClient<TAdapter, TransactionAdapterOf<TAdapter>> : {});
 /** The client available inside a transaction callback. */
 type QubuTransaction = QubuClient<QueryAdapter>;
 /** The streaming client available inside a streaming transaction callback. */
@@ -638,6 +654,7 @@ interface QubuStreamingTransactionalClient<TAdapter extends StreamingTransaction
   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 NestedTransactionalQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuClientFor<TAdapter>;
 declare function qubu<TAdapter extends ExplainableQueryAdapter & StreamingTransactionalQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuExplainableStreamingTransactionalClient<TAdapter>;
 declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuExplainableTransactionalClient<TAdapter> & QubuStreamingExplainableClient<TAdapter>;
 declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuExplainableTransactionalClient<TAdapter, TransactionAdapterOf<TAdapter>>;
@@ -649,8 +666,11 @@ declare function qubu<TAdapter extends TransactionalQueryAdapter>(adapter: TAdap
 declare function qubu<TAdapter extends StreamingQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuStreamingClient<TAdapter>;
 declare function qubu<TAdapter extends QueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuClient<TAdapter>;
 interface DriverValueEncoder<TDriverValue = unknown> {
-  /** Convert one Qubu parameter into the driver's bindable representation. */
-  encode(value: unknown): TDriverValue;
+  /**
+   * Convert one Qubu parameter into the driver's bindable representation and receive its SQL
+   * domain.
+   */
+  encode(value: unknown, sqlType?: SqlTypeName): TDriverValue;
 }
 /**
  * Render a typed query, pass it to an application adapter, and return the adapter's structured
@@ -798,6 +818,10 @@ type GeneratedColumnDescriptor = ExpressionGeneratedColumnDescriptor | ExternalG
 type GeneratedDescriptor = GeneratedColumnDescriptor;
 /** Identity generation policy. Identity is not an ordinary SQL expression. */
 type IdentityGeneration = "always" | "by-default";
+/** Literal or deterministic schema-expression identity option value. */
+type IdentityOptionValue = SchemaLiteralValue | AnySchemaExpression;
+/** Dialect-neutral identity options retained in Snapshot v1. */
+type IdentityOptions = Readonly<Record<string, IdentityOptionValue>>;
 /** 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. */
@@ -814,6 +838,7 @@ type IdentityDialectExtension = SqliteIdentityExtension | MysqlIdentityExtension
 interface IdentityDescriptor {
   readonly kind: "identity";
   readonly generation: IdentityGeneration;
+  readonly options?: IdentityOptions;
   /** Optional dialect-owned identity semantics such as SQLite AUTOINCREMENT. */
   readonly dialect?: IdentityDialectExtension;
 }
@@ -838,6 +863,7 @@ declare function externalGeneratedColumn(): ExternalGeneratedColumnDescriptor;
 /** Describe a database identity column without inventing a generated SQL expression. */
 declare function identityColumn(generation?: IdentityGeneration, options?: {
   readonly dialect?: IdentityDialectExtension;
+  readonly options?: IdentityOptions;
 }): IdentityDescriptor;
 /** The normalized behavior fields attached to a column definition. */
 interface ResolvedColumnBehavior {
@@ -951,8 +977,12 @@ interface ColumnOptions<TOutput = unknown, TInsert = TOutput> {
   readonly onUpdate?: AnySchemaExpression;
   /** Override the snake_case SQL identifier derived from the field name. */
   readonly sqlName?: string;
+  /** Runtime SQL semantic domain name for adapter binding and result metadata. */
+  readonly sqlType?: SqlTypeName;
   /** Physical storage metadata for a custom column definition. */
   readonly storage?: ColumnStorage;
+  /** Dialect-owned column metadata retained by schema snapshots. */
+  readonly dialect?: SchemaDialectExtension;
   /** Override adapter decoding for values selected from this column. */
   readonly decode?: ResultDecoder;
   /** Convert values at the live application-to-driver boundary without affecting schema metadata. */
@@ -963,8 +993,9 @@ interface ColumnOptions<TOutput = unknown, TInsert = TOutput> {
    */
   readonly castType?: string;
 }
-type BuiltInColumnOptions<TOutput> = Omit<ColumnOptions<TOutput, TOutput>, "castType" | "storage"> & {
+type BuiltInColumnOptions<TOutput> = Omit<ColumnOptions<TOutput, TOutput>, "castType" | "sqlType" | "storage"> & {
   readonly castType?: never;
+  readonly sqlType?: never;
   readonly storage?: never;
 };
 /** Sparse type-level configuration carried by a column definition. */
@@ -1033,8 +1064,12 @@ interface ColumnDefinition<TConfig extends ColumnDefinitionConfig = {}> {
   /** MySQL's optional parameter-free `ON UPDATE` expression. */
   readonly onUpdate?: ColumnConfigOnUpdate<TConfig>;
   readonly sqlName?: string;
+  /** Runtime SQL semantic domain name for adapter binding and result metadata. */
+  readonly sqlType?: SqlTypeName;
   /** Physical storage metadata, separate from the application and SQL types. */
   readonly storage?: ColumnConfigStorage<TConfig>;
+  /** Dialect-owned metadata retained by schema snapshots. */
+  readonly dialect?: SchemaDialectExtension;
   /** Runtime decoder used when this definition is projected. */
   readonly resultDecoder?: ResultDecoder;
   /** Runtime default used when an application insert omits this definition. */
@@ -1266,9 +1301,13 @@ declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert,
 declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, const TOptions extends ColumnOptions<TOutput, TInsert> = {}, TSqlType extends AnySqlType = SqlUnknown>(options?: TOptions): ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType>;
 /** Resolve the runtime result metadata carried by a column definition. */
 declare function columnResultValue(definition: {
-  readonly storage?: ColumnStorage;
+  readonly sqlType?: SqlTypeName;
   readonly resultDecoder?: ResultDecoder;
 }): ResultValueMetadata | undefined;
+/** Resolve a column's explicit runtime semantic SQL domain for driver-facing metadata. */
+declare function columnSqlType(definition: {
+  readonly sqlType?: SqlTypeName;
+}): SqlTypeName | undefined;
 /** Apply a live column codec while preserving SQL NULL unchanged. */
 declare function encodeColumnParameter(definition: {
   readonly parameterEncoder?: (value: any) => unknown;
@@ -1352,10 +1391,16 @@ declare function mapResult<TOutput, TExpression extends AnyExpression>(expressio
 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>;
+/** Build a parameterized value expression with an optional runtime SQL domain for the adapter. */
+declare function value<T>(input: T, sqlType?: SqlTypeName): ValueExpression<T>;
+/**
+ * Bind a value while declaring its compile-time and runtime SQL semantic domain.
+ *
+ * @remarks
+ *   The domain is a binding hint; it does not select a JavaScript result decoder.
+ */
+declare function typedValue<TSqlType extends AnySqlType, T>(input: T, sqlType: TSqlType["sqlType"]): ValueExpression<T, TSqlType>;
+declare function asValue<TInput>(input: TInput, sqlType?: SqlTypeName): TInput extends AnyExpression ? TInput : ValueExpression<TInput>;
 //#endregion
 //#region src/expressions/operators/shared.d.ts
 type Operand<T> = T | ExpressionWithOutput<T>;
@@ -1687,39 +1732,40 @@ declare function typedCall<TSqlType extends AnySqlType, TOutput = unknown>(): <c
 } ? never : T_1 : never : never), "function">;
 //#endregion
 //#region src/expressions/functions/string.d.ts
+type TextOperandValidation<TInput> = SqlCapabilityValidation<OperandSqlType<TInput, SqlText>, SqlTextLike>;
 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 {
+type CoalesceValidation<TFirst, TRest extends readonly unknown[]> = TRest extends readonly [infer THead, ...infer TTail] ? SqlEqualityValidation<ExpressionSqlType<TFirst>, OperandSqlType<THead, ExpressionSqlType<TFirst>>> & CoalesceValidation<TFirst, TTail> : unknown;
+declare function lower<const TInput extends Operand<string>>(input: TInput & TextOperandValidation<TInput>): Expression<ResultMeta<string, (MetadataOf<TInput> extends (infer T) ? T extends MetadataOf<TInput> ? 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 {
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TInput> extends (infer T_2) ? T_2 extends MetadataOf<TInput> ? 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 {
+} ? TSource : never : never : never, SqlText> | ExpressionMeta<MetadataOf<TInput> extends (infer T_3) ? T_3 extends MetadataOf<TInput> ? 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 {
+} ? TDependencies : never : never : never> | (MetadataOf<TInput> extends (infer T_4) ? T_4 extends MetadataOf<TInput> ? 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 {
+} ? never : T_4 : never : never), "function"> & SchemaExpressionBrand & ResultValueCarrier;
+declare function upper<const TInput extends Operand<string>>(input: TInput & TextOperandValidation<TInput>): Expression<ResultMeta<string, (MetadataOf<TInput> extends (infer T) ? T extends MetadataOf<TInput> ? 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 {
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TInput> extends (infer T_2) ? T_2 extends MetadataOf<TInput> ? 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 {
+} ? TSource : never : never : never, SqlText> | ExpressionMeta<MetadataOf<TInput> extends (infer T_3) ? T_3 extends MetadataOf<TInput> ? 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 {
+} ? TDependencies : never : never : never> | (MetadataOf<TInput> extends (infer T_4) ? T_4 extends MetadataOf<TInput> ? 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 {
+} ? never : T_4 : never : never), "function"> & SchemaExpressionBrand & ResultValueCarrier;
+declare function coalesce<T, TFirst extends ExpressionWithOutput<T>, const TRest extends readonly Operand<NoInfer<T>>[]>(first: TFirst, ...rest: TRest & CoalesceValidation<TFirst, TRest>): Expression<ResultMeta<T, never, ExpressionSqlType<TFirst>> | ExpressionMeta<MetadataOf<[TFirst, ...TRest][number]> extends (infer T_1) ? T_1 extends MetadataOf<[TFirst, ...TRest][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 {
+} ? TDependencies : never : never : never> | (MetadataOf<[TFirst, ...TRest][number]> extends (infer T_2) ? T_2 extends MetadataOf<[TFirst, ...TRest][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 {
+} ? never : T_2 : never : never), "function"> & SchemaExpressionBrand & ResultValueCarrier;
+declare function concat<const TArguments extends readonly Operand<string>[]>(...argumentsToConcat: TArguments & TextArgumentsValidation<TArguments>): Expression<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";
@@ -1730,7 +1776,7 @@ declare function concat<const TArguments extends readonly Operand<string>[]>(...
   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">;
+} ? never : T_4 : never : never), "function"> & SchemaExpressionBrand & ResultValueCarrier;
 //#endregion
 //#region src/expressions/functions/window.d.ts
 type WindowOrder = AnyExpression | OrderTerm<any>;
@@ -2670,6 +2716,11 @@ type DeclaredColumnNullabilityOf<TColumn> = TColumn extends DeclaredColumnNullab
 //#endregion
 //#region src/schema/indexes.d.ts
 type IndexTerm = AnyExpression | OrderTerm<any>;
+/** Additional physical facts attached to one index term. */
+interface IndexTermOptions {
+  readonly prefixLength?: SchemaLiteralValue | AnySchemaExpression;
+  readonly operatorClass?: string;
+}
 /** PostgreSQL-specific index method and storage metadata. */
 interface PostgresIndexExtension extends SchemaDialectExtension<"postgresql"> {
   readonly method?: "btree" | "hash" | "gist" | "spgist" | "gin" | "brin";
@@ -2698,6 +2749,12 @@ interface IndexOptions<TPredicate extends AnyExpression | undefined = AnyExpress
   readonly include?: readonly ColumnReference<string, any>[];
   /** Typed engine-specific index options. */
   readonly dialect?: TExtension;
+  /** Exact engine index method, when it is not dialect-extension data. */
+  readonly method?: string;
+  /** Physical backing constraint name, when the engine exposes one. */
+  readonly backingConstraint?: string;
+  /** Prefix lengths and operator classes aligned with the terms array. */
+  readonly termOptions?: readonly (IndexTermOptions | undefined)[];
 }
 type IndexTermExpression$2<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;
@@ -2710,7 +2767,8 @@ 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;
+type HasTermOptions<TOptions> = "termOptions" extends keyof TOptions ? true : false;
+type IsCandidateKey<TTerms extends readonly IndexTerm[], TOptions extends IndexOptions<any>> = HasTermOptions<TOptions> extends true ? false : UniqueOption<TOptions> extends false ? false : PredicatePresence<TOptions> extends true ? false : AllEligibleColumns<TTerms> extends false ? false : UniqueOption<TOptions> extends true ? PredicatePresence<TOptions> extends false ? AllEligibleColumns<TTerms> extends true ? true : boolean : boolean : boolean;
 /** 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";
@@ -2721,6 +2779,9 @@ interface TableIndex<TTerms extends readonly IndexTerm[] = any, TOptions extends
     readonly include: infer TIncluded;
   } ? TIncluded : undefined;
   readonly dialect?: DialectOption<TOptions>;
+  readonly method?: "method" extends keyof TOptions ? TOptions["method"] : undefined;
+  readonly backingConstraint?: "backingConstraint" extends keyof TOptions ? TOptions["backingConstraint"] : undefined;
+  readonly termOptions?: "termOptions" extends keyof TOptions ? TOptions["termOptions"] : undefined;
   readonly candidateKey: IsCandidateKey<TTerms, TOptions>;
 }
 /** The widened index shape accepted by source metadata records. */
@@ -2731,6 +2792,9 @@ interface SourceIndex {
   readonly predicate: AnyExpression | undefined;
   readonly includedColumns?: readonly ColumnReference<string, any>[];
   readonly dialect?: IndexDialectExtension;
+  readonly method?: string;
+  readonly backingConstraint?: string;
+  readonly termOptions?: readonly (IndexTermOptions | undefined)[];
   readonly candidateKey: boolean;
 }
 type SourceIndexesRecord = Readonly<Record<string, SourceIndex>>;
@@ -2878,11 +2942,15 @@ interface MysqlConstraintExtension extends SchemaDialectExtension<"mysql"> {
 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 {
+  /** Whether the database constraint has been validated. */
+  readonly validated?: boolean;
   /** 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> {
+  /** Physical backing index name, when exposed by the database. */
+  readonly backingIndex?: string;
   /** Whether the key can be deferred by a supporting dialect. */
   readonly deferrable?: boolean;
   /** Initial enforcement timing for a deferrable key. */
@@ -2890,6 +2958,8 @@ interface KeyConstraintOptions<TExtension extends ConstraintDialectExtension | u
 }
 /** Options for a database unique constraint, including nullable columns. */
 interface UniqueConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
+  /** Physical backing index name, when exposed by the database. */
+  readonly backingIndex?: string;
   /**
    * SQL NULL comparison semantics. `distinct` is the common default in which multiple NULL values
    * do not conflict; `not-distinct` permits at most one.
@@ -2930,6 +3000,8 @@ interface KeyConstraint<TKind extends "primary-key" | "unique" = "primary-key" |
   readonly columns: TColumns;
   readonly physicalName?: string;
   readonly dialect?: ConstraintDialectExtension;
+  readonly validated?: boolean;
+  readonly backingIndex?: string;
   readonly deferrable?: boolean;
   readonly initially?: ConstraintTiming;
 }
@@ -2946,6 +3018,7 @@ interface ForeignKeyConstraint<TColumns extends readonly AnyKeyColumn[] = readon
   readonly target: TTarget;
   readonly physicalName?: string;
   readonly dialect?: ConstraintDialectExtension;
+  readonly validated?: boolean;
   readonly onUpdate?: ReferentialAction;
   readonly onDelete?: ReferentialAction;
   readonly match?: ForeignKeyMatch;
@@ -2959,6 +3032,8 @@ interface UniqueConstraint<TColumns extends readonly AnyKeyColumn[] = readonly A
   readonly nulls: TNulls;
   readonly physicalName?: string;
   readonly dialect?: ConstraintDialectExtension;
+  readonly validated?: boolean;
+  readonly backingIndex?: string;
   readonly deferrable?: boolean;
   readonly initially?: ConstraintTiming;
 }
@@ -2968,6 +3043,7 @@ interface CheckConstraint<TExpression extends AnyExpression = AnyExpression> ext
   readonly expression: TExpression;
   readonly physicalName?: string;
   readonly dialect?: ConstraintDialectExtension;
+  readonly validated?: boolean;
   readonly deferrable?: boolean;
   readonly initially?: ConstraintTiming;
 }
@@ -3237,14 +3313,14 @@ interface SchemaDialectHooks {
  * 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> {
+interface SchemaDialect<TCapabilities extends string = 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>;
+declare function createSchemaDialect<const TCapabilities extends string = DialectCapability>(queryDialect: Dialect<TCapabilities>, schema: SchemaDialectHooks): SchemaDialect<TCapabilities>;
 //#endregion
 //#region src/query/selection.d.ts
 /**
@@ -3499,13 +3575,15 @@ interface MutationQuery<TConfig extends MutationQueryConfig = {}> extends Query<
 }> {
   readonly queryKind: MutationConfigKind<TConfig>;
 }
-type MutationCapabilityMetadata<T> = CapabilityMetadataOf<T>;
+/** Metadata inherited from clauses and expressions composed into a mutation. */
+type MutationMetadata<T> = CapabilityMetadataOf<T> | RequiresOuterMetadataOf<T>;
 interface AllowAllClause extends Fragment<never> {
   readonly clauseKind: "allow-all";
 }
 declare function allowAll(): AllowAllClause;
 type MutationConditionClause = WhereClause<any>;
-type MutationClause = MutationConditionClause | AllowAllClause | MutationReturningClause;
+type MutationWithClause = WithClause<any>;
+type MutationClause = MutationConditionClause | AllowAllClause | MutationReturningClause | MutationWithClause;
 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>;
@@ -3513,20 +3591,61 @@ type MutationRow<TClauses extends readonly unknown[]> = ReturningRow<MutationRet
 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-from.d.ts
+/** A PostgreSQL FROM clause that contributes typed sources to an UPDATE scope. */
+interface UpdateFromClause<TSources extends readonly AnySource[] = readonly AnySource[], TMetadata = RequiresOuterMetadataOf<TSources[number]> | CapabilityMetadataOf<TSources[number]> | RequiresCapabilityMeta<"update-from">> extends Fragment<TMetadata> {
+  readonly clauseKind: "update-from";
+  readonly sources: TSources;
+}
+/** Introduce one or more PostgreSQL sources to an UPDATE statement. */
+declare function updateFrom<const TSources extends readonly [AnySource, ...AnySource[]]>(...sources: TSources): UpdateFromClause<TSources>;
+/** Source identities introduced to an UPDATE by updateFrom(). */
+type UpdateFromScope<T> = T extends UpdateFromClause<infer TSources> ? ProvidedSourceIdentity<TSources[number]> : never;
+//#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<{
+type AssignmentScopeValidation<TTable extends AnyTable, TAssignments, TClauses extends readonly UpdateClause[]> = [Exclude<RequiresOf<TAssignments extends object ? TAssignments[keyof TAssignments] : never>, SourceIdentity<TTable> | UpdateFromScope<TClauses[number]>>] extends [never] ? unknown : QueryTypeValidation<"missing-source", "update.assignments", "Use expressions scoped to the update table or an updateFrom() source.", Exclude<RequiresOf<TAssignments extends object ? TAssignments[keyof TAssignments] : never>, SourceIdentity<TTable> | UpdateFromScope<TClauses[number]>>>;
+type UpdateClause = MutationClause | UpdateFromClause;
+type UpdateScopeValidation<TTable extends AnyTable, TClauses extends readonly UpdateClause[]> = [Exclude<RequiresOf<TClauses[number]>, SourceIdentity<TTable> | UpdateFromScope<TClauses[number]>>] extends [never] ? unknown : QueryTypeValidation<"missing-source", "mutation.scope", "Use clauses that reference the update table or an updateFrom() source.", Exclude<RequiresOf<TClauses[number]>, SourceIdentity<TTable> | UpdateFromScope<TClauses[number]>>>;
+type UpdateFromSourceValidation<TClauses extends readonly UpdateClause[]> = [Exclude<RequiresOuterOf<Extract<TClauses[number], UpdateFromClause>>, UpdateFromScope<TClauses[number]>>] extends [never] ? unknown : QueryTypeValidation<"missing-source", "update.from", "Use FROM sources whose outer requirements are provided by another updateFrom() source.", Exclude<RequiresOuterOf<Extract<TClauses[number], UpdateFromClause>>, UpdateFromScope<TClauses[number]>>>;
+declare function update<const TTable extends AnyTable, const TAssignments extends object, const TClauses extends readonly UpdateClause[]>(table: TTable, assignments: TAssignments & InvalidUpdateAssignments<TTable, TAssignments> & AssignmentScopeValidation<TTable, TAssignments, TClauses>, ...clauses: TClauses & UpdateScopeValidation<TTable, TClauses> & UpdateFromSourceValidation<TClauses> & MutationSafetyValidation<TClauses>): MutationQuery<{
   readonly row: MutationRow<TClauses>;
   readonly kind: "update";
-  readonly metadata: MutationCapabilityMetadata<TClauses[number] | (TAssignments extends object ? TAssignments[keyof TAssignments] : never)>;
+  readonly metadata: MutationMetadata<TClauses[number] | (TAssignments extends object ? TAssignments[keyof TAssignments] : never)>;
   readonly sqlTypes: MutationSqlTypes<TClauses>;
 }>;
 //#endregion
+//#region src/query/mutation/on-duplicate-key-update.d.ts
+/** Identity of the proposed row for one MySQL INSERT target. */
+type IncomingIdentity<TIdentity> = {
+  readonly sourceKind: "mysql-incoming";
+  readonly table: TIdentity;
+};
+/** Typed proposed-row columns usable only in duplicate-key assignments. */
+type IncomingColumns<TTable extends AnyTable> = SourceColumns<SourceRow<TTable>, IncomingIdentity<SourceIdentity<TTable>>, SourceSqlTypeMap<TTable>>;
+/**
+ * Reference the incoming row in MySQL duplicate-key assignments. INSERT SELECT exposes only its
+ * explicit target columns; other references fail during rendering. These references cannot be used
+ * as a FROM source.
+ */
+declare function incoming<const TTable extends AnyTable>(table: TTable): IncomingColumns<TTable>;
+type AssignmentValidation<TTable extends AnyTable, TAssignments extends object> = TAssignments extends UpdateAssignments<TTable> ? Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>> extends never ? Exclude<RequiresOf<TAssignments[keyof TAssignments]> | RequiresOuterOf<TAssignments[keyof TAssignments]>, SourceIdentity<TTable> | IncomingIdentity<SourceIdentity<TTable>>> extends never ? unknown : QueryTypeValidation<"missing-source", "upsert.duplicate-key.assignments", "Use only the target table and its incoming row."> : QueryTypeValidation<"invalid-update", "upsert.duplicate-key.assignments", "Use only writable target columns."> : QueryTypeValidation<"invalid-update", "upsert.duplicate-key.assignments", "Provide target-compatible assignment values.">;
+/** MySQL INSERT clause; conflicts are determined by the database's keys. */
+interface OnDuplicateKeyUpdateClause<TTable extends AnyTable = AnyTable, TAssignments extends object = object> extends Fragment<RequiresCapabilityMeta<"on-duplicate-key-update"> | RequiresSourceMeta<SourceIdentity<TTable>> | CapabilityMetadataOf<TAssignments[keyof TAssignments]>> {
+  readonly clauseKind: "on-duplicate-key-update";
+  readonly table: TTable;
+}
+/**
+ * Update writable columns when a MySQL INSERT row conflicts with a key. Raw values use target
+ * column encoders. Expressions may reference the target table or incoming(table). At least one
+ * non-omitted assignment is required.
+ */
+declare function onDuplicateKeyUpdate<const TTable extends AnyTable, const TAssignments extends object>(table: TTable, assignments: TAssignments & AssignmentValidation<TTable, TAssignments>): OnDuplicateKeyUpdateClause<TTable, TAssignments>;
+//#endregion
 //#region src/query/mutation/on-conflict.d.ts
 type ExcludedIdentity<TTableIdentity> = {
   readonly sourceKind: "excluded";
@@ -3556,8 +3675,15 @@ 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 TableIndexes<TTable extends AnyTable> = TTable extends {
+  readonly indexes: infer TIndexes extends SourceIndexesRecord;
+} ? TIndexes : never;
+type PostgresUniqueIndex<TIndex> = TIndex extends SourceIndex ? TIndex["unique"] extends true ? [Exclude<TIndex["dialect"], undefined>] extends [never] ? TIndex : Exclude<TIndex["dialect"], undefined> extends {
+  readonly dialect: "postgresql";
+} ? TIndex : never : never : never;
+type TableConflictIndex<TTable extends AnyTable> = PostgresUniqueIndex<TableIndexes<TTable>[keyof TableIndexes<TTable>]>;
+/** A declared primary key, unique constraint, or PostgreSQL-compatible unique index. */
+type ConflictTarget<TTable extends AnyTable = AnyTable> = TableKeyConstraint<TTable> | TableConflictIndex<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>>>;
@@ -3565,10 +3691,10 @@ type ConflictActionValidation<TTable extends AnyTable, TAction extends ConflictA
 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 target: KeyConstraint | SourceIndex | undefined;
   readonly action: TAction;
 }
-type InsertClause = MutationReturningClause | OnConflictClause;
+type InsertClause = MutationReturningClause | OnConflictClause | MutationWithClause | OnDuplicateKeyUpdateClause<any, any>;
 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
@@ -3589,9 +3715,14 @@ interface InsertSelectSource<TQuery extends AnyQuery = AnyQuery, TColumns extend
 }
 declare function insertSelect<TQuery extends AnyQuery, 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 InsertSourceMetadata<TSource extends InsertSource> = TSource extends InsertSelectSource<infer TQuery, any> ? CapabilityMetadataOf<TQuery> | RequiresOuterMetadataOf<TQuery> : TSource extends ValuesSource<infer TRows> ? CapabilityMetadataOf<InsertRowsValue<TRows>> : never;
+/** A raw application input or target-compatible expression accepted by an insert field. */
+type InsertValue<T> = T | ExpressionWithOutput<T>;
+/** Writable table fields accepted by {@link insertInto} through {@link values}. */
+type InsertValuesRow<TTable extends AnyTable> = { -readonly [K in keyof TableInsertInput<TTable["definitions"]>]: InsertValue<TableInsertInput<TTable["definitions"]>[K]>; };
+type InsertRowsValue<TRows extends readonly object[]> = TRows[number] extends (infer TRow) ? TRow extends object ? TRow[keyof TRow] : never : never;
+type InsertValuesScopeValidation<TSource extends InsertSource> = TSource extends ValuesSource<infer TRows> ? [RequiresOf<InsertRowsValue<TRows>>] extends [never] ? unknown : QueryTypeValidation<"missing-source", "insert.values.row", "Use source-free expressions in INSERT values.", RequiresOf<InsertRowsValue<TRows>>> : unknown;
+type InvalidInsertRow<TTable extends AnyTable, TRow> = TRow extends InsertValuesRow<TTable> ? Exclude<keyof TRow, keyof InsertValuesRow<TTable>> extends never ? unknown : QueryTypeValidation<"invalid-insert", "insert.values.columns", "Use only columns declared by the insert table.", Exclude<keyof TRow, keyof InsertValuesRow<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;
 } | {
@@ -3601,10 +3732,14 @@ type ValidInsertSource<TTable extends AnyTable, TSource extends InsertSource> =
 } | {
   hasRuntimeDefault: 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<{
+declare function insertInto<const TTable extends AnyTable, const TSource extends InsertSource, const TClauses extends readonly InsertClause[]>(table: TTable, source: TSource & ValidInsertSource<TTable, TSource> & InsertValuesScopeValidation<TSource>, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses> & (Extract<TClauses[number], {
+  clauseKind: "on-duplicate-key-update";
+}> extends never ? unknown : Extract<TClauses[number], {
+  clauseKind: "returning";
+}> extends never ? unknown : QueryTypeValidation<"invalid-mutation", "insert.duplicate-key", "MySQL duplicate-key updates do not support RETURNING.">)): MutationQuery<{
   readonly row: MutationRow<TClauses>;
   readonly kind: "insert";
-  readonly metadata: MutationCapabilityMetadata<TClauses[number]> | InsertSourceCapabilityMetadata<TSource>;
+  readonly metadata: MutationMetadata<TClauses[number]> | InsertSourceMetadata<TSource>;
   readonly sqlTypes: MutationSqlTypes<TClauses>;
 }>;
 //#endregion
@@ -3612,10 +3747,41 @@ declare function insertInto<const TTable extends AnyTable, const TSource extends
 declare function deleteFrom<const TTable extends AnyTable, const TClauses extends readonly MutationClause[]>(table: TTable, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses> & MutationSafetyValidation<TClauses>): MutationQuery<{
   readonly row: MutationRow<TClauses>;
   readonly kind: "delete";
-  readonly metadata: MutationCapabilityMetadata<TClauses[number]>;
+  readonly metadata: MutationMetadata<TClauses[number]>;
   readonly sqlTypes: MutationSqlTypes<TClauses>;
 }>;
 //#endregion
+//#region src/expressions/nested-json.d.ts
+type JsonSourceQuery = AnyQuery & {
+  readonly queryKind: "select" | "set";
+};
+type JsonQueryExpression<TQuery, TOutput> = Expression<ResultMeta<TOutput, never, SqlJson<TOutput>> | InheritedMetadata<TQuery> | SubqueryMeta, "subquery">;
+type ObjectQueryValidation<TQuery> = 0 extends 1 & CardinalityOf<TQuery> ? QueryTypeValidation<"invalid-subquery", "jsonObjectFrom.query", "Prove at most one row with fetchFirst(1)."> : [CardinalityOf<TQuery>] extends ["exactly-one" | "zero-or-one"] ? unknown : QueryTypeValidation<"invalid-subquery", "jsonObjectFrom.query", "Prove at most one row with fetchFirst(1).">;
+/**
+ * Turn a SELECT or set query into an inferred array expression; empty queries return [].
+ *
+ * Preserves correlation, explicit ordering and pagination on PostgreSQL, MySQL 8.0.21+, and SQLite
+ * 3.45+. Without ORDER BY, element order is unspecified. DISTINCT ordering must use expressions
+ * present in the projection.
+ *
+ * Nested fields require supported runtime SQL domains. Bigints, binary values and serialized JSON
+ * use exact text transport; dates and booleans are normalized without adapter-specific decoders.
+ * Unsupported domains or lossy numeric representations throw. Custom result decoders receive the
+ * transport value (including strings for bigint, decimal, binary hex and JSON), consistent with
+ * their unknown-input contract.
+ */
+declare function jsonArrayFrom<TQuery extends JsonSourceQuery>(query: TQuery): JsonQueryExpression<TQuery, QueryRow<TQuery>[]>;
+/**
+ * Turn a query proven to return at most one row into an inferred object.
+ *
+ * Empty queries return null; exactly-one queries retain a non-null result type. Use an
+ * unconditional fetchFirst(1) to prove the row bound for a table query. Shares dialect, projection
+ * and exact-decoding rules with {@link jsonArrayFrom}.
+ *
+ * @throws {TypeError} When the query lacks a runtime at-most-one-row proof.
+ */
+declare function jsonObjectFrom<TQuery extends JsonSourceQuery>(query: TQuery & ObjectQueryValidation<TQuery>): JsonQueryExpression<TQuery, QueryRow<TQuery> | ([CardinalityOf<TQuery>] extends ["exactly-one"] ? never : null)>;
+//#endregion
 //#region src/query/clauses/order-by.d.ts
 type OrderDirection = "ASC" | "DESC";
 type NullsOrder = "FIRST" | "LAST";
@@ -3657,6 +3823,7 @@ type AnyTable = Source<any> & {
   readonly definitions: TableDefinitions;
   /** Application field keys mapped to physical SQL column names. */
   readonly sqlNames: Readonly<Record<string, string>>;
+  readonly dialect?: SchemaDialectExtension;
 };
 type TableRow<TDefinitions extends TableDefinitions> = { -readonly [K in keyof TDefinitions]: ColumnOutput<TDefinitions[K]>; };
 /** SQL semantic domains derived from a table's column definitions. */
@@ -3683,11 +3850,13 @@ type Table<TName extends string = string, TDefinitions extends TableDefinitions
   readonly columns: TableColumns<TDefinitions, TableIdentity<TName>>;
   readonly constraints: TConstraints;
   readonly indexes: TIndexes;
+  readonly dialect?: SchemaDialectExtension;
 } & 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;
+  readonly dialect?: SchemaDialectExtension;
 }
 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>>;
@@ -3798,9 +3967,10 @@ interface CustomSourceOptions<TIdentity, TDefinitions extends TableDefinitions>
   readonly columns: TDefinitions;
   readonly sourceKind?: SourceKind;
 }
-type CustomSource<TIdentity, TDefinitions extends TableDefinitions> = Source<{
+type CustomSource<TIdentity, TDefinitions extends TableDefinitions, TMetadata = never> = Source<{
   readonly identity: TIdentity;
   readonly row: TableRow<TDefinitions>;
+  readonly metadata: TMetadata;
   readonly sqlTypes: TableSqlTypes<TDefinitions>;
 }> & {
   readonly identity: TIdentity;
@@ -3819,7 +3989,7 @@ declare function createSource<TIdentity, TRow extends object, TMetadata = never,
  * 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>;
+declare function customSource<const TIdentity, const TDefinitions extends TableDefinitions, const TMetadata = never>(options: CustomSourceOptions<TIdentity, TDefinitions>): CustomSource<TIdentity, TDefinitions, TMetadata>;
 /**
  * Add convenient direct column properties without allowing a column name to overwrite the source's
  * rendering or metadata primitives.
@@ -3845,9 +4015,13 @@ interface Query<TConfig extends QueryConfig = {}> extends Fragment<ResultMeta<re
   /** @internal Type-level configuration retained for inference. */
   readonly __queryConfig?: TConfig;
   readonly queryKind: QueryKind;
+  /** @internal Runtime row-bound proof retained by built-in query constructors. */
+  readonly cardinality?: QueryCardinality;
   readonly row: QueryConfigRow<TConfig>;
   /** Runtime metadata used to decode named result fields. */
   readonly resultShape: ResultShape;
+  /** @internal Render a SELECT with an ordering ordinal for nested JSON aggregation. */
+  readonly renderJsonRows?: (context: RenderContext, ordinal: string) => void;
   /** Type-only SQL domains of the named query projection. */
   readonly sqlTypes?: QueryConfigSqlTypes<TConfig>;
 }
@@ -3869,7 +4043,7 @@ type QuerySqlTypeMap<T> = T extends {
 //#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";
+type DialectCapability = "ilike" | "json" | "on-conflict" | "on-duplicate-key-update" | "row-locking" | "update-from";
 /**
  * Optional dialect hook used by schema expressions when a JavaScript value must become SQL text
  * instead of a query parameter.
@@ -3932,7 +4106,7 @@ interface ExplainRenderOptions {
 interface DialectExplain {
   readonly render: (statement: string, queryKind: QueryKind, options: ExplainRenderOptions) => string;
 }
-interface Dialect<TCapabilities extends DialectCapability = DialectCapability> {
+interface Dialect<TCapabilities extends string = string> {
   readonly name: string;
   quoteIdentifier(identifier: string): string;
   placeholder(position: number): string;
@@ -3950,7 +4124,7 @@ interface Dialect<TCapabilities extends DialectCapability = DialectCapability> {
   /** 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> {
+interface DialectOptions<TCapabilities extends string = never, TJson extends DialectJson | undefined = DialectJson | undefined> {
   readonly name: string;
   readonly quoteIdentifier?: (identifier: string) => string;
   readonly placeholder: (position: number) => string;
@@ -3972,20 +4146,401 @@ 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> & {
+declare function createDialect<const TCapabilities extends string = 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>;
+declare function createDialect<const TCapabilities extends string = 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;
+declare function assertDialectCapability(dialect: Dialect<string>, capability: string): void;
+/** Extend a dialect with capabilities owned by an addon without changing its SQL policies. */
+declare function extendDialect<const TCapabilities extends string, const TAdditionalCapabilities extends string>(dialect: Dialect<TCapabilities>, additionalCapabilities: readonly TAdditionalCapabilities[]): Dialect<TCapabilities | TAdditionalCapabilities>;
+//#endregion
+//#region src/snapshot/complete-types.d.ts
+/** The canonical schema snapshot envelope tag. */
+declare const completeSchemaSnapshotFormat: "qubu-schema";
+/** The current strict format version for the complete catalog/object model. */
+declare const completeSchemaSnapshotVersion: 1;
+/** Descriptive alias for consumers that select a numbered snapshot version. */
+declare const schemaSnapshotV1Version: 1;
+/** Explicit format-version aliases for generated tooling and fixtures. */
+declare const schemaSnapshotCompleteVersion: 1;
+declare const schemaSnapshotVersion1: 1;
+/** Object families that may appear in a complete canonical snapshot. */
+type CompleteSnapshotObjectKind = "namespace" | "table" | "column" | "constraint" | "index" | "view" | "materialized-view" | "sequence" | "enum" | "domain" | "collation" | "trigger" | "routine" | "partition" | "policy" | "extension" | "comment" | "ownership" | "deferred-object" | "opaque-object";
+/** Object families that can own nested complete snapshot objects. */
+type CompleteSnapshotObjectOwnerKind = "table" | "view" | "materialized-view" | "domain";
+/** A non-recursive owner scope for a nested complete snapshot object. */
+interface CompleteSnapshotObjectOwner {
+  readonly kind: CompleteSnapshotObjectOwnerKind;
+  readonly id: string;
+}
+/** A stable logical object reference used by complete snapshot relations. */
+interface CompleteSnapshotObjectReference {
+  readonly kind: Exclude<CompleteSnapshotObjectKind, "namespace">;
+  readonly id: string;
+  /** Required when the target is a nested column, constraint, or index. */
+  readonly owner?: CompleteSnapshotObjectOwner;
+}
+/** Source evidence retained without persisting a database catalog key. */
+interface CompleteSnapshotProvenance {
+  readonly kind: "catalog" | "decompiler" | "create-sql";
+  readonly dialect: string;
+  readonly path?: readonly (string | number)[];
+}
+/** Physical-name evidence retained without ephemeral catalog identity keys. */
+interface CompleteSnapshotPhysicalReference {
+  readonly kind: CompleteSnapshotObjectKind;
+  readonly namespace?: string;
+  readonly table?: string;
+  readonly name: string;
+}
+/** Namespace identity and selected physical boundary for a snapshot. */
+interface CompleteSnapshotNamespace extends CompleteSnapshotObjectMetadata {
+  readonly kind: "generic" | "postgres-schema" | "sqlite-database" | "mysql-database";
+  readonly name: string;
+}
+/** Capability facts reported by the adapter that produced the snapshot. */
+interface CompleteSnapshotCapabilities {
+  readonly generatedColumns: boolean;
+  readonly identityMetadata: boolean;
+  readonly checkConstraints: boolean;
+  readonly checkConstraintEnforcement: "enforced" | "metadata-only" | "unknown";
+  readonly expressionDecompilation: boolean;
+  readonly indexExpressions: boolean;
+  readonly indexPredicates: boolean;
+  readonly indexIncludedColumns: boolean;
+  readonly namespaces: boolean;
+  readonly visibility: "complete" | "limited" | "unknown";
+  readonly [capability: string]: boolean | string;
+}
+/** Metadata common to every complete snapshot object. */
+interface CompleteSnapshotObjectMetadata {
+  readonly provenance?: CompleteSnapshotProvenance;
+  readonly physicalReference?: CompleteSnapshotPhysicalReference;
+  readonly dialect?: SnapshotDialectExtension;
+}
+/** A complete snapshot column, including physical ordinal evidence. */
+interface CompleteSnapshotColumn extends CompleteSnapshotObjectMetadata {
+  readonly kind: "column";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly ordinalPosition: number;
+  readonly nullable: boolean;
+  readonly hasDefault: boolean;
+  readonly generated: boolean;
+  readonly storage?: SnapshotStorage;
+  readonly default?: SnapshotDefault;
+  readonly generatedColumn?: SnapshotGeneratedColumn;
+  readonly identity?: CompleteSnapshotIdentity;
+  readonly onUpdate?: SnapshotExpression;
+}
+/** A richer identity declaration retained beside a column or sequence. */
+interface CompleteSnapshotIdentity extends CompleteSnapshotObjectMetadata {
+  readonly kind: "identity";
+  readonly generation: "always" | "by-default";
+  readonly options: Readonly<Record<string, CompleteSnapshotValueFact>>;
+}
+/** A literal or opaque expression value in complete object metadata. */
+type CompleteSnapshotValueFact = {
+  readonly kind: "literal";
+  readonly value: SnapshotLiteral;
+} | {
+  readonly kind: "expression";
+  readonly expression: SnapshotExpression;
+};
+/** An ordered column or expression term in a complete index. */
+type CompleteSnapshotIndexTerm = {
+  readonly kind: "column";
+  readonly column: string;
+  readonly position: number;
+  readonly direction?: "ASC" | "DESC";
+  readonly nulls?: "FIRST" | "LAST";
+  readonly prefixLength?: CompleteSnapshotValueFact;
+  readonly operatorClass?: string;
+} | {
+  readonly kind: "expression";
+  readonly expression: SnapshotExpression;
+  readonly position: number;
+  readonly direction?: "ASC" | "DESC";
+  readonly nulls?: "FIRST" | "LAST";
+  readonly operatorClass?: string;
+};
+/** A complete index with engine-specific method and included-column facts. */
+interface CompleteSnapshotIndex extends CompleteSnapshotObjectMetadata {
+  readonly kind: "index";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly terms: readonly CompleteSnapshotIndexTerm[];
+  readonly unique: boolean;
+  readonly candidateKey: boolean;
+  readonly predicate?: SnapshotExpression;
+  readonly includedColumns?: readonly string[];
+  readonly backingConstraint?: CompleteSnapshotObjectReference;
+  readonly method?: string;
+}
+/** A key or uniqueness constraint in a complete table. */
+interface CompleteSnapshotKeyConstraint extends CompleteSnapshotObjectMetadata {
+  readonly kind: "primary-key" | "unique" | "unique-constraint";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly string[];
+  readonly nulls?: "distinct" | "not-distinct";
+  readonly backingIndex?: CompleteSnapshotObjectReference;
+  readonly deferrable?: boolean;
+  readonly initially?: "immediate" | "deferred";
+  readonly validated?: boolean;
+}
+/** A foreign key with explicit target object identity and actions. */
+interface CompleteSnapshotForeignKey extends CompleteSnapshotObjectMetadata {
+  readonly kind: "foreign-key";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly string[];
+  readonly target: {
+    readonly table: CompleteSnapshotObjectReference;
+    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 validated?: boolean;
+}
+/** A check constraint whose expression remains tagged data. */
+interface CompleteSnapshotCheckConstraint extends CompleteSnapshotObjectMetadata {
+  readonly kind: "check";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly expression: SnapshotExpression;
+  readonly deferrable?: boolean;
+  readonly initially?: "immediate" | "deferred";
+  readonly validated?: boolean;
+}
+/** Every constraint represented by the complete neutral snapshot model. */
+type CompleteSnapshotConstraint = CompleteSnapshotKeyConstraint | CompleteSnapshotForeignKey | CompleteSnapshotCheckConstraint;
+/** A complete table record keyed by stable logical identity. */
+interface CompleteSnapshotTable extends CompleteSnapshotObjectMetadata {
+  readonly kind: "table";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly CompleteSnapshotColumn[];
+  readonly constraints: readonly CompleteSnapshotConstraint[];
+  readonly indexes: readonly CompleteSnapshotIndex[];
+}
+/** A view or materialized-view declaration and its output columns. */
+interface CompleteSnapshotView extends CompleteSnapshotObjectMetadata {
+  readonly kind: "view" | "materialized-view";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly CompleteSnapshotColumn[];
+  readonly definition: SnapshotExpression;
+  readonly dependencies?: readonly CompleteSnapshotObjectReference[];
+  readonly checkOption?: "none" | "local" | "cascaded";
+  readonly securityBarrier?: boolean;
+  readonly securityInvoker?: boolean;
+}
+/** A sequence and its exact option facts. */
+interface CompleteSnapshotSequence extends CompleteSnapshotObjectMetadata {
+  readonly kind: "sequence";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly storage?: SnapshotStorage;
+  readonly start?: CompleteSnapshotValueFact;
+  readonly increment?: CompleteSnapshotValueFact;
+  readonly minimum?: CompleteSnapshotValueFact;
+  readonly maximum?: CompleteSnapshotValueFact;
+  readonly cache?: CompleteSnapshotValueFact;
+  readonly cycle?: boolean;
+  readonly ownedBy?: CompleteSnapshotObjectReference;
+  readonly identity?: CompleteSnapshotIdentity;
+}
+/** An ordered enum declaration. */
+interface CompleteSnapshotEnum extends CompleteSnapshotObjectMetadata {
+  readonly kind: "enum";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly values: readonly {
+    readonly value: string;
+    readonly ordinalPosition: number;
+    readonly provenance?: CompleteSnapshotProvenance;
+  }[];
+}
+/** A domain declaration and its base type constraints. */
+interface CompleteSnapshotDomain extends CompleteSnapshotObjectMetadata {
+  readonly kind: "domain";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly storage: SnapshotStorage;
+  readonly nullable?: boolean;
+  readonly default?: CompleteSnapshotValueFact;
+  readonly constraints?: readonly CompleteSnapshotCheckConstraint[];
+}
+/** Collation behavior that can affect deterministic schema comparison. */
+interface CompleteSnapshotCollation extends CompleteSnapshotObjectMetadata {
+  readonly kind: "collation";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly provider?: string;
+  readonly locale?: string;
+  readonly deterministic?: boolean;
+  readonly version?: string;
+}
+/** Trigger declaration attached to a table or view. */
+interface CompleteSnapshotTrigger extends CompleteSnapshotObjectMetadata {
+  readonly kind: "trigger";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly table: CompleteSnapshotObjectReference;
+  readonly timing: "before" | "after" | "instead-of" | "unknown";
+  readonly events: readonly ("insert" | "update" | "delete" | "truncate")[];
+  readonly orientation?: "row" | "statement";
+  readonly condition?: SnapshotExpression;
+  readonly body: SnapshotExpression;
+  readonly enabled?: boolean;
+}
+/** Routine argument declaration. */
+interface CompleteSnapshotRoutineParameter {
+  readonly name?: string;
+  readonly mode?: "in" | "out" | "inout" | "variadic" | "table";
+  readonly storage: SnapshotStorage;
+  readonly default?: CompleteSnapshotValueFact;
+  readonly ordinalPosition: number;
+  readonly provenance?: CompleteSnapshotProvenance;
+}
+/** Function, procedure, aggregate, or window routine declaration. */
+interface CompleteSnapshotRoutine extends CompleteSnapshotObjectMetadata {
+  readonly kind: "routine";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly routineKind: "function" | "procedure" | "aggregate" | "window" | "unknown";
+  readonly parameters: readonly CompleteSnapshotRoutineParameter[];
+  readonly returnType?: SnapshotStorage;
+  readonly language?: string;
+  readonly body?: SnapshotExpression;
+  readonly volatility?: "immutable" | "stable" | "volatile" | "unknown";
+  readonly parallel?: "safe" | "restricted" | "unsafe" | "unknown";
+  readonly security?: "invoker" | "definer" | "unknown";
+  readonly dependencies?: readonly CompleteSnapshotObjectReference[];
+}
+/** A partition child, its parent, and normalized bound expression. */
+interface CompleteSnapshotPartition extends CompleteSnapshotObjectMetadata {
+  readonly kind: "partition";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly parent: CompleteSnapshotObjectReference;
+  readonly strategy: "range" | "list" | "hash" | "reference" | "unknown";
+  readonly keyColumns?: readonly string[];
+  readonly bound?: SnapshotExpression;
+  readonly default?: boolean;
+}
+/** A row-level security policy attached to a table. */
+interface CompleteSnapshotPolicy extends CompleteSnapshotObjectMetadata {
+  readonly kind: "policy";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly table: CompleteSnapshotObjectReference;
+  readonly command: "all" | "select" | "insert" | "update" | "delete" | "unknown";
+  readonly roles?: readonly string[];
+  readonly permissive?: boolean;
+  readonly using?: SnapshotExpression;
+  readonly check?: SnapshotExpression;
+}
+/** An extension object with a typed, versioned payload. */
+interface CompleteSnapshotExtension extends CompleteSnapshotObjectMetadata {
+  readonly kind: "extension";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly extensionName: string;
+  readonly extensionVersion?: string;
+  readonly schema?: string;
+  readonly data: SnapshotJsonValue;
+  readonly configuration?: SnapshotJsonValue;
+}
+/** A deferred object retained as a reviewable, non-lossy boundary record. */
+interface CompleteSnapshotDeferredObject extends CompleteSnapshotObjectMetadata {
+  readonly kind: "deferred-object";
+  readonly id: string;
+  readonly objectKind: string;
+  readonly physicalName: string;
+  readonly reason?: string;
+  readonly data?: SnapshotJsonValue;
+}
+/** An opaque object observed by an adapter but not yet structurally modeled. */
+interface CompleteSnapshotOpaqueObject extends CompleteSnapshotObjectMetadata {
+  readonly kind: "opaque-object";
+  readonly id: string;
+  readonly objectKind: string;
+  readonly physicalName: string;
+  readonly data: SnapshotJsonValue;
+  readonly sql?: SnapshotExpression;
+}
+/** A comment attached to a stable logical object. */
+interface CompleteSnapshotComment extends CompleteSnapshotObjectMetadata {
+  readonly kind: "comment";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly object: CompleteSnapshotObjectReference;
+  readonly text: string;
+}
+/** Ownership metadata attached to a stable logical object. */
+interface CompleteSnapshotOwnership extends CompleteSnapshotObjectMetadata {
+  readonly kind: "ownership";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly object: CompleteSnapshotObjectReference;
+  readonly owner: string;
+}
+/** Every complete snapshot object family, including retained boundaries. */
+type CompleteSnapshotObject = CompleteSnapshotTable | CompleteSnapshotView | CompleteSnapshotSequence | CompleteSnapshotEnum | CompleteSnapshotDomain | CompleteSnapshotCollation | CompleteSnapshotTrigger | CompleteSnapshotRoutine | CompleteSnapshotPartition | CompleteSnapshotPolicy | CompleteSnapshotExtension | CompleteSnapshotDeferredObject | CompleteSnapshotOpaqueObject | CompleteSnapshotComment | CompleteSnapshotOwnership;
+/** The immutable strict Snapshot v1 envelope. */
+interface CompleteSchemaSnapshot {
+  readonly format: typeof completeSchemaSnapshotFormat;
+  readonly version: typeof completeSchemaSnapshotVersion;
+  readonly dialect: SnapshotDialect;
+  readonly namingPolicy: SnapshotNamingPolicy;
+  readonly namespace: CompleteSnapshotNamespace;
+  readonly capabilities: CompleteSnapshotCapabilities;
+  readonly tables: readonly CompleteSnapshotTable[];
+  readonly views: readonly CompleteSnapshotView[];
+  readonly sequences: readonly CompleteSnapshotSequence[];
+  readonly enums: readonly CompleteSnapshotEnum[];
+  readonly domains: readonly CompleteSnapshotDomain[];
+  readonly collations: readonly CompleteSnapshotCollation[];
+  readonly triggers: readonly CompleteSnapshotTrigger[];
+  readonly routines: readonly CompleteSnapshotRoutine[];
+  readonly partitions: readonly CompleteSnapshotPartition[];
+  readonly policies: readonly CompleteSnapshotPolicy[];
+  readonly extensions: readonly CompleteSnapshotExtension[];
+  readonly deferredObjects: readonly CompleteSnapshotDeferredObject[];
+  readonly opaqueObjects: readonly CompleteSnapshotOpaqueObject[];
+  readonly comments: readonly CompleteSnapshotComment[];
+  readonly ownership: readonly CompleteSnapshotOwnership[];
+}
+/** Input accepted by the strict complete snapshot encoder. */
+type CompleteSchemaSnapshotInput = CompleteSchemaSnapshot | Readonly<Record<string, unknown>>;
+/** A complete snapshot decoder result with immutable successful output. */
+type CompleteSnapshotDecodeResult = {
+  readonly ok: true;
+  readonly value: CompleteSchemaSnapshot;
+} | {
+  readonly ok: false;
+  readonly diagnostics: readonly SnapshotDiagnostic[];
+};
+/** A complete snapshot creation result with immutable successful output. */
+type CompleteSnapshotCreateResult = CompleteSnapshotDecodeResult;
+/** V1 aliases kept explicit for consumers that prefer numbered APIs. */
+type SchemaSnapshotV1 = CompleteSchemaSnapshot;
+type SchemaSnapshotV1Input = CompleteSchemaSnapshotInput;
+type SchemaSnapshotV1DecodeResult = CompleteSnapshotDecodeResult;
 //#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. */
+/** The current canonical schema snapshot format version. */
 declare const schemaSnapshotVersion: 1;
 /** The first version of the dialect-extension envelope. */
 declare const schemaSnapshotDialectVersion: 1;
@@ -4075,27 +4630,11 @@ type SnapshotGeneratedColumn = {
 } | {
   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. */
+/** V1 object aliases kept in the short snapshot vocabulary used by consumers. */
+type SnapshotIdentity = CompleteSnapshotIdentity;
+type SnapshotColumn = CompleteSnapshotColumn;
+type SnapshotIndexTerm = CompleteSnapshotIndexTerm;
+/** The expression portion of an index term, without ordering metadata. */
 type SnapshotIndexTermExpression = {
   readonly kind: "column";
   readonly column: string;
@@ -4103,92 +4642,16 @@ type SnapshotIndexTermExpression = {
   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;
+type SnapshotKeyConstraint = CompleteSnapshotKeyConstraint;
+type SnapshotUniqueConstraint = CompleteSnapshotKeyConstraint & {
   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[];
-}
+};
+type SnapshotForeignKey = CompleteSnapshotForeignKey;
+type SnapshotCheckConstraint = CompleteSnapshotCheckConstraint;
+type SnapshotConstraint = CompleteSnapshotConstraint;
+type SnapshotIndex = CompleteSnapshotIndex;
+type SnapshotTable = CompleteSnapshotTable;
+type SchemaSnapshot = CompleteSchemaSnapshot;
 /** Schema-expression context supplied to a dialect adapter. */
 interface SnapshotExpressionContext {
   readonly mode: "default" | "generated" | "check" | "index";
@@ -4215,7 +4678,7 @@ interface SnapshotValidationContext {
  * 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> {
+interface SchemaSnapshotAdapter<TCapabilities extends string = DialectCapability> {
   /** The query dialect plus its schema hooks and metadata. */
   readonly dialect: SchemaDialect<TCapabilities>;
 }
@@ -4229,24 +4692,12 @@ interface SnapshotDiagnostic {
   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[];
-};
+type SnapshotDecodeResult = CompleteSnapshotDecodeResult;
 /** Result returned by a non-throwing schema traversal helper. */
-type SnapshotCreateResult = {
-  readonly ok: true;
-  readonly value: SchemaSnapshot;
-} | {
-  readonly ok: false;
-  readonly diagnostics: readonly SnapshotDiagnostic[];
-};
+type SnapshotCreateResult = CompleteSnapshotCreateResult;
 /** A schema snapshot input accepted by the canonical encoder. */
-type SchemaSnapshotInput = SchemaSnapshot | Readonly<Record<string, unknown>>;
+type SchemaSnapshotInput = CompleteSchemaSnapshotInput;
 /** Expose the schema generic in tooling declarations without widening APIs. */
 type AnySchema = Schema<any>;
 //#endregion
-export { PaginationKind as $, SqlTag as $a, QubuStreamingTransaction as $c, SourceIndexesRecord as $i, AggregateMeta as $l, WithClause as $n, ColumnStorageDialectOf as $o, generatedTableName as $r, ResolvedColumnBehavior as $s, nullsLast as $t, SqlNumericLike as $u, SnapshotStorage as A, jsonBoolean as Aa, ExplainReadOptions as Ac, catalogCheck as Ai, ExpressionNullability as Al, MutationReturningClause as An, value as Ao, SchemaExpressionErrorCode as Ar, numeric as As, SourceSqlTypeMap as At, RequiresOuterMetadataOf as Au, CastTarget as B, concat as Ba, HookQueryOperation as Bc, AliasedSource as Bi, withDialectCapability as Bl, select as Bn, ColumnHasDefault as Bo, renderSchemaSql as Br, DefaultDescriptor as Bs, TableDefinitions as Bt, isFragment as Bu, SnapshotIndexTerm as C, SelectClause as Ca, ExecutionOptions as Cc, SourceConstraintsRecord as Ci, ColumnDependency as Cl, update as Cn, isTrue as Co, SelectionSqlTypes as Cr, date as Cs, SourceColumns as Ct, ProvidesOuterSourceMeta as Cu, SnapshotLiteral as D, multiply as Da, ExplainOptions as Dc, UniqueConstraint as Di, AnySchemaExpression as Dl, MutationQuery as Dn, SqlCapabilityValidation as Do, createSchemaDialect as Dr, nativeColumn as Ds, SourceKind as Dt, RenderFunction as Du, SnapshotKeyConstraint as E, modulo as Ea, ExplainMutationOptions as Ec, TableLike as Ei, AnyExpression as El, MutationKind as En, OperandSqlType as Eo, SchemaDialectHooks as Er, json as Es, SourceIdentity as Et, RenderContext as Eu, neutralSnapshotDialect as F, denseRank as Fa, HookMetadata as Fc, references as Fi, SchemaExpression as Fl, ReturningClause as Fn, ColumnDefaultOf as Fo, UnsafeSchemaSqlExpression as Fr, CanonicalLiteral as Fs, exposeColumns as Ft, SqlTypeOf as Fu, DialectJson as G, typedCall as Ga, QubuClient as Gc, alias as Gi, ResultDecodingError as Gl, MissingScope as Gn, ColumnIsNullable as Go, SchemaNamingPolicy as Gr, GeneratedColumnDescriptor as Gs, TableRow as Gt, SqlBinary as Gu, DialectCapability as H, upper as Ha, HookSuccessOutcome as Hc, LateralSource as Hi, ResultDecodeContext as Hl, AvailableScope as Hn, ColumnIdentityOf as Ho, unsafeSchemaSql as Hr, ExpressionGeneratedColumnDescriptor as Hs, TableInsertInput as Ht, sequence as Hu, schemaSnapshotDialectVersion as I, over as Ia, HookMetadataValue as Ic, unique as Ii, SchemaExpressionBrand as Il, ReturningRow as In, ColumnDefinition as Io, defineSchemaExpression as Ir, ColumnBehaviorError as Is, sourceIdentity as It, SubqueryMeta as Iu, DialectRowLocking as J, countDistinct as Ja, QubuExplainableTransactionalClient as Jc, IndexOptions as Ji, booleanResultDecoder as Jl, ScopeValidation as Jn, ColumnOutput as Jo, SchemaTableNames as Jr, IdentityDescriptor as Js, table as Jt, SqlDecimal as Ju, DialectOptions as K, avg as Ka, QubuExplainableClient as Kc, lateral as Ki, ResultField as Kl, RequiredOuterScope as Kn, ColumnOnUpdateOf as Ko, SchemaOptions as Kr, GeneratedColumnMode as Ks, TableSqlTypes as Kt, SqlBoolean as Ku, schemaSnapshotFormat as L, rank as La, HookOperation as Lc, uniqueConstraint as Li, isExpression as Ll, ReturningSqlTypes as Ln, ColumnDefinitionConfig as Lo, isUnsafeSchemaSql as Lr, ColumnBehaviorErrorCode as Ls, AnyTable as Lt, VisibleDependenciesOf as Lu, SnapshotTable as M, jsonNumber as Ma, ExplainResult as Mc, check as Mi, ExpressionRequires as Ml, MutationScopeValidation as Mn, cast as Mo, SchemaExpressionMode as Mr, text as Ms, UnknownSourceSqlTypes as Mt, RequiresOuterSourceMeta as Mu, SnapshotUniqueConstraint as N, jsonPath as Na, ExplainableQueryAdapter as Nc, foreignKey as Ni, ExpressionSqlType as Nl, MutationSqlTypes as Nn, typedCast as No, SchemaRenderContext as Nr, timestamp as Ns, createSource as Nt, RequiresSourceMeta as Nu, SnapshotNamingPolicy as O, subtract as Oa, ExplainOptionsFor as Oc, UniqueConstraintOptions as Oi, Expression as Ol, MutationQueryConfig as On, asValue as Oo, RenderedSchemaExpression as Or, nativeStorage as Os, SourceProvision as Ot, RequiresCapabilityMeta as Ou, SnapshotValidationContext as P, jsonText as Pa, HookErrorOutcome as Pc, primaryKey as Pi, ExpressionWithOutput as Pl, allowAll as Pn, ColumnCodec as Po, SchemaRenderOptions as Pr, uuid as Ps, customSource as Pt, ResultMeta as Pu, NamedCastTarget as Q, SqlFragment as Qa, QubuStreamingExplainableClient as Qc, SourceIndex as Qi, AggregateDependenciesOf as Ql, RecursiveCteSource as Qn, ColumnStorageDescriptor as Qo, defaultSchemaNamingPolicy as Qr, MysqlIdentityExtension as Qs, nullsFirst as Qt, SqlJson as Qu, schemaSnapshotNamingPolicyVersion as R, rowNumber as Ra, HookOperationKind as Rc, validateConstraintDialect as Ri, makeExpression as Rl, returning as Rn, ColumnFromOptions as Ro, normalizeSchemaSql as Rr, ColumnDefault as Rs, Table as Rt, WindowMeta as Ru, SnapshotIndex as S, ClausePlacement as Sa, DriverValueEncoder as Sc, SourceConstraint as Si, QueryValidationIssue as Sl, UpdateAssignments as Sn, isNull as So, SelectionOutput as Sr, columnResultValue as Ss, Source as St, ProvidesOuterOf as Su, SnapshotJsonValue as T, divide as Ta, ExecutionResult as Tc, SqliteConstraintExtension as Ti, expressionFragment as Tl, MutationClause as Tn, OperandNullability as To, SchemaDialect as Tr, integer as Ts, SourceConstraints as Tt, QueryCardinality as Tu, DialectCastTypes as U, call as Ua, HookTransactionOperation as Uc, QueryAliasIdentity as Ui, ResultDecoder as Ul, ClauseScope as Un, ColumnInsertInput as Uo, Schema as Ur, ExternalDefaultDescriptor as Us, TableMetadataCallback as Ut, AnySqlType as Uu, Dialect as V, lower as Va, HookStreamEnd as Vc, LateralIdentity as Vi, DecodableResultType as Vl, AvailableOuterScope as Vn, ColumnHasRuntimeDefault as Vo, schemaExpression as Vr, ExpressionDefaultDescriptor as Vs, TableIdentity as Vt, parenthesize as Vu, DialectExplain as W, schemaCall as Wa, OperationEndHook as Wc, QuerySource as Wi, ResultDecoders as Wl, GroupingValidation as Wn, ColumnIsGenerated as Wo, SchemaDiagnostic as Wr, ExternalGeneratedColumnDescriptor as Ws, TableOptions as Wt, SqlBigInt as Wu, ExplainRenderOptions as X, min as Xa, QubuOptions as Xc, MysqlIndexExtension as Xi, jsonTextResultDecoder as Xl, SelectQuery as Xn, ColumnStorage as Xo, SchemaTableRegistry as Xr, IdentityGeneration as Xs, asc as Xt, SqlEqualityCompatible as Xu, ExplainFormat as Y, max as Ya, QubuHooks as Yc, IndexTerm as Yi, dateResultDecoder as Yl, SelectCardinality as Yn, ColumnSqlType as Yo, SchemaTableRecord as Yr, IdentityDialectExtension as Ys, OrderTerm as Yt, SqlEqualityComparable as Yu, JsonScalarKind as Z, sum as Za, QubuStreamingClient as Zc, PostgresIndexExtension as Zi, timestampResultDecoder as Zl, CteSource as Zn, ColumnStorageDeclarationOf as Zo, SchemaValidationError as Zr, LiteralDefaultDescriptor as Zs, desc as Zt, SqlInteger as Zu, SnapshotExpressionContext as _, fetchNext as _a, generatedSchemaObjectName as _c, KeyConstraint as _i, RenderedQuery as _l, doNothing as _n, notLike as _o, FromScope as _r, StorageTypeOf as _s, AnySource as _t, MetadataOf as _u, SnapshotBigInt as a, and as aa, generatedColumn as ac, SqlTimestamp as ad, CheckConstraint as ai, StreamableQuery as al, InsertSource as an, notExists as ao, except as ar, DialectNativeStorage as as, SchemaLiteralRenderer as at, DependenciesOf as au, SnapshotGeneratedColumn as b, distinct as ba, materializeSchemaObjectRecord as bc, PostgresConstraintExtension as bi, QueryValidationError as bl, onConflict as bn, notIn as bo, Selection as br, boolean as bs, ProvidedSourceIdentity as bt, NullableSourcesOf as bu, SnapshotConstraint as c, Omit$1 as ca, SchemaDialectExtension as cc, SqlUuid as cd, ConstraintOptions as ci, TransactionOptions as cl, insertInto as cn, eq as co, unionAll as cr, NativeStorageDescriptor as cs, resolveCastTarget as ct, FragmentMeta as cu, SnapshotDefault as d, omit as da, SchemaMetadataValidationError as dc, FieldLikeOptions as di, executeRows as dl, ConflictAction as dn, isDistinctFrom as do, innerJoin as dr, PortableStorageDescriptor as ds, QueryConfig as dt, GroupingMeta as du, SqliteIndexExtension as ea, SchemaLiteralValue as ec, SqlOrderCompatible as ed, schema as ei, QubuStreamingTransactionalClient as el, order as en, TypedSqlTag as eo, cte as er, ColumnStorageKindOf as es, PaginationPart as et, AnyFragment as eu, SnapshotDiagnostic as f, where as fa, SchemaObjectIdentity as fc, ForeignKeyConstraint as fi, explain as fl, ConflictTarget as fn, isNotDistinctFrom as fo, leftJoin as fr, PortableStorageType as fs, QueryKind as ft, HasAggregate as fu, SnapshotExpression as g, fetchFirst as ga, freezeSchemaMetadata as gc, ForeignKeyTargetInput as gi, RenderOptions as gl, OnConflictClause as gn, ne as go, FromClause as gr, StorageOf as gs, Row as gt, InheritedMetadataOf as gu, SnapshotDialectExtension as h, rowLock as ha, dialectMismatchDiagnostic as hc, ForeignKeyTarget as hi, RenderCapabilityValidation as hl, ExcludedSource as hn, lte as ho, groupBy as hr, StorageDialectOf as hs, QueryWithRow as ht, InheritedMetadata as hu, SchemaSnapshotInput as i, DeclaredColumnNullability as ia, externalGeneratedColumn as ic, SqlTextLike as id, CatalogCheckSql as ii, QueryExecutor as il, InsertSelectSource as in, inQuery as io, SetQuery as ir, ColumnUpdateInput as is, RowLockWaitPolicy as it, CardinalityOf as iu, SnapshotStorageContext as j, jsonExists as ja, ExplainRequest as jc, catalogForeignKey as ji, ExpressionOutput as jl, MutationRow as jn, mapResult as jo, SchemaExpressionInput as jr, portableStorage as js, SourceSqlTypes as jt, RequiresOuterOf as ju, SnapshotSpecialNumber as k, JsonPath as ka, ExplainPlanRow as kc, UniqueNullSemantics as ki, ExpressionKind as kl, MutationReturning as kn, typedValue as ko, SchemaExpressionError as kr, nullable as ks, SourceRow as kt, RequiresOf as ku, SnapshotCreateResult as l, OmittableSelectClause as la, SchemaDialectName as lc, ConstraintTiming as li, TransactionalQueryAdapter as ll, insertSelect as ln, gt as lo, crossJoin as lr, PortableColumnStorage as ls, AnyQuery as lt, GroupingDependenciesOf as lu, SnapshotDialect as m, RowLockOptions as ma, assertSchemaDialectSupport as mc, ForeignKeyOptions as mi, stream as ml, DoUpdateAction as mn, lt as mo, rightJoin as mr, StorageDescriptor as ms, QuerySqlTypeMap as mt, HasWindow as mu, SchemaSnapshot as n, index as na, canonicalLiteral as nc, SqlSemanticType as nd, AnyKeyColumn as ni, QubuTransactionalClient as nl, deleteFrom as nn, caseWhen as no, withCte as nr, ColumnStorageType as ns, PortableCastType as nt, CapabilityMetadataOf as nu, SnapshotCheckConstraint as o, not as oa, identityColumn as oc, SqlTypeSatisfies as od, CheckConstraintOptions as oi, StreamingQueryAdapter as ol, ValuesSource as on, scalar as oo, intersect as or, NativeColumnStorage as os, assertDialectCapability as ot, ExpressionMeta as ou, SnapshotDiagnosticCode as p, RowLockClause as pa, SchemaObjectNameOptions as pc, ForeignKeyMatch as pi, qubu as pl, DoNothingAction as pn, like as po, naturalJoin as pr, StorageDeclarationOf as ps, QueryRow as pt, HasSubquery as pu, DialectPagination as q, count as qa, QubuExplainableStreamingTransactionalClient as qc, IndexDialectExtension as qi, ResultShape as ql, RequiredScope as qn, ColumnOptions as qo, SchemaTableEntry as qr, GeneratedDescriptor as qs, TableUpdateInput as qt, SqlDate as qu, SchemaSnapshotAdapter as r, validateIndexDialect as ra, externalDefault as rc, SqlText as rd, CatalogCheckExpression as ri, QueryAdapter as rl, DefaultValuesSource as rn, exists as ro, SetOperator as rr, ColumnStorageTypeOf as rs, RowLockMode as rt, CardinalityMeta as ru, SnapshotColumn as s, or as sa, resolveColumnBehavior as sc, SqlUnknown as sd, ConstraintDialectExtension as si, StreamingTransactionalQueryAdapter as sl, defaultValues as sn, ComparisonValidation as so, union as sr, NativeStorage as ss, createDialect as st, Fragment as su, AnySchema as t, TableIndex as ta, SqliteIdentityExtension as tc, SqlOrderable as td, schemaNamingPolicyVersion as ti, QubuTransaction as tl, orderBy as tn, sql as to, recursiveCte as tr, ColumnStorageOf as ts, PortableCastTarget as tt, CapabilitiesOf as tu, SnapshotDecodeResult as u, SelectPart as ua, SchemaMetadataDiagnostic as uc, FieldLike as ui, execute as ul, values as un, gte as uo, fullJoin as ur, PortableStorage as us, Query as ut, GroupingKeysOf as uu, SnapshotExtensionContext as v, offset as va, isValidSchemaObjectName as vc, KeyConstraintOptions as vi, render as vl, doUpdate as vn, between as vo, FromSource as vr, bigint as vs, CustomSource as vt, NullabilityOf as vu, SnapshotIndexTermExpression as w, add as wa, ExecutionRequest as wc, SourceLike as wi, ColumnReference as wl, AllowAllClause as wn, Operand as wo, all as wr, encodeColumnParameter as ws, SourceConfig as wt, ProvidesSourceMeta as wu, SnapshotIdentity as x, AnySelectClause as xa, AdapterExecutionResult as xc, ReferentialAction as xi, QueryValidationErrorCode as xl, UpdateAssignmentValue as xn, isNotNull as xo, SelectionObject as xr, column as xs, ProvidedSourceRow as xt, OutputOf as xu, SnapshotForeignKey as y, having as ya, materializeSchemaObjectIdentity as yc, MysqlConstraintExtension as yi, QueryTypeValidation as yl, excluded as yn, inList as yo, from as yr, binary as ys, CustomSourceOptions as yt, NullableSourceMeta as yu, schemaSnapshotVersion as z, coalesce as za, HookOutcome as zc, AliasIdentity as zi, markExpressionCategory as zl, correlate as zn, ColumnGeneratedOf as zo, renderSchemaExpression as zr, ColumnDefaultInput as zs, TableColumns as zt, fragment as zu };
+export { CompleteSnapshotExtension as $, IndexDialectExtension as $a, GeneratedColumnDescriptor as $c, isFragment as $d, SchemaTableEntry as $i, HookTransactionOperation as $l, DefaultValuesSource as $n, avg as $o, RequiredScope as $r, ColumnOnUpdateOf as $s, assertDialectCapability as $t, ResultDecodeContext as $u, SnapshotStorage as A, SourceLike as Aa, columnSqlType as Ac, MetadataOf as Ad, all as Ai, materializeSchemaObjectRecord as Al, sourceIdentity as An, SelectClause as Ao, AllowAllClause as Ar, isTrue as As, schemaSnapshotCompleteVersion as At, QueryTypeValidation as Au, CompleteSchemaSnapshot as B, primaryKey as Ba, text as Bc, RenderFunction as Bd, SchemaRenderOptions as Bi, ExplainReadOptions as Bl, TableSqlTypes as Bn, jsonPath as Bo, allowAll as Br, typedCast as Bs, DialectPagination as Bt, ExpressionKind as Bu, SnapshotIndexTerm as C, KeyConstraint as Ca, StorageOf as Cc, GroupingKeysOf as Cd, FromScope as Ci, SchemaObjectNameOptions as Cl, SourceRow as Cn, fetchFirst as Co, onDuplicateKeyUpdate as Cr, ne as Cs, CompleteSnapshotValueFact as Ct, explain as Cu, SnapshotLiteral as D, ReferentialAction as Da, boolean as Dc, HasWindow as Dd, SelectionObject as Di, generatedSchemaObjectName as Dl, createSource as Dn, distinct as Do, UpdateFromClause as Dr, notIn as Ds, SchemaSnapshotV1Input as Dt, RenderOptions as Du, SnapshotKeyConstraint as E, PostgresConstraintExtension as Ea, binary as Ec, HasSubquery as Ed, Selection as Ei, freezeSchemaMetadata as El, UnknownSourceSqlTypes as En, having as Eo, update as Er, inList as Es, SchemaSnapshotV1DecodeResult as Et, RenderCapabilityValidation as Eu, neutralSnapshotDialect as F, UniqueNullSemantics as Fa, nativeColumn as Fc, ProvidesOuterOf as Fd, SchemaExpressionError as Fi, ExecutionResult as Fl, TableIdentity as Fn, subtract as Fo, MutationReturning as Fr, asValue as Fs, DialectCapability as Ft, ColumnReference as Fu, CompleteSnapshotColumn as G, AliasIdentity as Ga, ColumnBehaviorErrorCode as Gc, RequiresOuterSourceMeta as Gd, renderSchemaExpression as Gi, HookMetadata as Gl, desc as Gn, rowNumber as Go, correlate as Gr, ColumnFromOptions as Gs, NamedCastTarget as Gt, ExpressionWithOutput as Gu, CompleteSnapshotCapabilities as H, unique as Ha, uuid as Hc, RequiresOf as Hd, defineSchemaExpression as Hi, ExplainResult as Hl, table as Hn, denseRank as Ho, ReturningRow as Hr, ColumnDefaultOf as Hs, ExplainFormat as Ht, ExpressionOutput as Hu, schemaSnapshotDialectVersion as I, catalogCheck as Ia, nativeStorage as Ic, ProvidesOuterSourceMeta as Id, SchemaExpressionErrorCode as Ii, ExplainMutationOptions as Il, TableInsertInput as In, JsonPath as Io, MutationReturningClause as Ir, typedValue as Is, DialectCastTypes as It, expressionFragment as Iu, CompleteSnapshotCreateResult as J, LateralSource as Ja, DefaultDescriptor as Jc, SqlTypeOf as Jd, unsafeSchemaSql as Ji, HookOperationKind as Jl, order as Jn, lower as Jo, AvailableScope as Jr, ColumnHasRuntimeDefault as Js, PortableCastTarget as Jt, isExpression as Ju, CompleteSnapshotComment as K, AliasedSource as Ka, ColumnDefault as Kc, RequiresSourceMeta as Kd, renderSchemaSql as Ki, HookMetadataValue as Kl, nullsFirst as Kn, coalesce as Ko, select as Kr, ColumnGeneratedOf as Ks, PaginationKind as Kt, SchemaExpression as Ku, schemaSnapshotFormat as L, catalogForeignKey as La, nullable as Lc, ProvidesSourceMeta as Ld, SchemaExpressionInput as Li, ExplainOptions as Ll, TableMetadataCallback as Ln, jsonBoolean as Lo, MutationRow as Lr, value as Ls, DialectExplain as Lt, AnyExpression as Lu, SnapshotTable as M, TableLike as Ma, encodeColumnParameter as Mc, NullableSourceMeta as Md, SchemaDialectHooks as Mi, DriverValueEncoder as Ml, Table as Mn, divide as Mo, MutationKind as Mr, OperandNullability as Ms, schemaSnapshotVersion1 as Mt, QueryValidationErrorCode as Mu, SnapshotUniqueConstraint as N, UniqueConstraint as Na, integer as Nc, NullableSourcesOf as Nd, createSchemaDialect as Ni, ExecutionOptions as Nl, TableColumns as Nn, modulo as No, MutationQuery as Nr, OperandSqlType as Ns, CastTarget as Nt, QueryValidationIssue as Nu, SnapshotNamingPolicy as O, SourceConstraint as Oa, column as Oc, InheritedMetadata as Od, SelectionOutput as Oi, isValidSchemaObjectName as Ol, customSource as On, AnySelectClause as Oo, UpdateFromScope as Or, isNotNull as Os, completeSchemaSnapshotFormat as Ot, RenderedQuery as Ou, SnapshotValidationContext as P, UniqueConstraintOptions as Pa, json as Pc, OutputOf as Pd, RenderedSchemaExpression as Pi, ExecutionRequest as Pl, TableDefinitions as Pn, multiply as Po, MutationQueryConfig as Pr, SqlCapabilityValidation as Ps, Dialect as Pt, ColumnDependency as Pu, CompleteSnapshotEnum as Q, lateral as Qa, ExternalGeneratedColumnDescriptor as Qc, fragment as Qd, SchemaOptions as Qi, HookSuccessOutcome as Ql, deleteFrom as Qn, typedCall as Qo, RequiredOuterScope as Qr, ColumnIsNullable as Qs, SchemaLiteralRenderer as Qt, DecodableResultType as Qu, schemaSnapshotNamingPolicyVersion as R, check as Ra, numeric as Rc, QueryCardinality as Rd, SchemaExpressionMode as Ri, ExplainOptionsFor as Rl, TableOptions as Rn, jsonExists as Ro, MutationScopeValidation as Rr, mapResult as Rs, DialectJson as Rt, AnySchemaExpression as Ru, SnapshotIndex as S, ForeignKeyTargetInput as Sa, StorageDialectOf as Sc, GroupingDependenciesOf as Sd, SqlUuid as Sf, FromClause as Si, SchemaObjectIdentity as Sl, SourceProvision as Sn, rowLock as So, incoming as Sr, lte as Ss, CompleteSnapshotTrigger as St, executeRows as Su, SnapshotJsonValue as T, MysqlConstraintExtension as Ta, bigint as Tc, HasAggregate as Td, from as Ti, dialectMismatchDiagnostic as Tl, SourceSqlTypes as Tn, offset as To, UpdateAssignments as Tr, between as Ts, SchemaSnapshotV1 as Tt, stream as Tu, CompleteSnapshotCheckConstraint as U, uniqueConstraint as Ua, CanonicalLiteral as Uc, RequiresOuterMetadataOf as Ud, isUnsafeSchemaSql as Ui, ExplainableQueryAdapter as Ul, OrderTerm as Un, over as Uo, ReturningSqlTypes as Ur, ColumnDefinition as Us, ExplainRenderOptions as Ut, ExpressionRequires as Uu, CompleteSchemaSnapshotInput as V, references as Va, timestamp as Vc, RequiresCapabilityMeta as Vd, UnsafeSchemaSqlExpression as Vi, ExplainRequest as Vl, TableUpdateInput as Vn, jsonText as Vo, ReturningClause as Vr, ColumnCodec as Vs, DialectRowLocking as Vt, ExpressionNullability as Vu, CompleteSnapshotCollation as W, validateConstraintDialect as Wa, ColumnBehaviorError as Wc, RequiresOuterOf as Wd, normalizeSchemaSql as Wi, HookErrorOutcome as Wl, asc as Wn, rank as Wo, returning as Wr, ColumnDefinitionConfig as Ws, JsonScalarKind as Wt, ExpressionSqlType as Wu, CompleteSnapshotDeferredObject as X, QuerySource as Xa, ExpressionGeneratedColumnDescriptor as Xc, VisibleDependenciesOf as Xd, SchemaDiagnostic as Xi, HookQueryOperation as Xl, jsonArrayFrom as Xn, call as Xo, GroupingValidation as Xr, ColumnInsertInput as Xs, RowLockMode as Xt, markExpressionCategory as Xu, CompleteSnapshotDecodeResult as Y, QueryAliasIdentity as Ya, ExpressionDefaultDescriptor as Yc, SubqueryMeta as Yd, Schema as Yi, HookOutcome as Yl, orderBy as Yn, upper as Yo, ClauseScope as Yr, ColumnIdentityOf as Ys, PortableCastType as Yt, makeExpression as Yu, CompleteSnapshotDomain as Z, alias as Za, ExternalDefaultDescriptor as Zc, WindowMeta as Zd, SchemaNamingPolicy as Zi, HookStreamEnd as Zl, jsonObjectFrom as Zn, schemaCall as Zo, MissingScope as Zr, ColumnIsGenerated as Zs, RowLockWaitPolicy as Zt, withDialectCapability as Zu, SnapshotExpressionContext as _, FieldLikeOptions as _a, PortableStorage as _c, CardinalityOf as _d, SqlTextLike as _f, innerJoin as _i, resolveColumnBehavior as _l, SourceColumns as _n, SelectPart as _o, excluded as _r, gte as _s, CompleteSnapshotProvenance as _t, StreamingQueryAdapter as _u, SnapshotBigInt as a, generatedTableName as aa, ColumnStorageDescriptor as ac, bigintResultDecoder as ad, SqlBoolean as af, WithClause as ai, IdentityOptionValue as al, QueryConfig as an, SourceIndex as ao, defaultValues as ar, SqlFragment as as, CompleteSnapshotNamespace as at, QubuExplainableTransactionalClient as au, SnapshotGeneratedColumn as b, ForeignKeyOptions as ba, StorageDeclarationOf as bc, Fragment as bd, SqlTypeSatisfies as bf, rightJoin as bi, SchemaMetadataDiagnostic as bl, SourceIdentity as bn, RowLockClause as bo, IncomingIdentity as br, like as bs, CompleteSnapshotSequence as bt, TransactionalQueryAdapter as bu, SnapshotConstraint as c, AnyKeyColumn as ca, ColumnStorageOf as cc, jsonTextResultDecoder as cd, SqlEqualityComparable as cf, withCte as ci, MysqlIdentityExtension as cl, QuerySqlTypeMap as cn, TableIndex as co, values as cr, sql as cs, CompleteSnapshotObjectMetadata as ct, QubuStreamingClient as cu, SnapshotDefault as d, CheckConstraint as da, ColumnUpdateInput as dc, AggregateDependenciesOf as dd, SqlJson as df, except as di, SqliteIdentityExtension as dl, AnySource as dn, DeclaredColumnNullability as do, DoNothingAction as dr, inQuery as ds, CompleteSnapshotObjectReference as dt, QubuStreamingTransactionalClient as du, SchemaTableNames as ea, ColumnOptions as ec, ResultDecoder as ed, parenthesize as ef, ScopeValidation as ei, GeneratedColumnMode as el, createDialect as en, IndexOptions as eo, InsertSelectSource as er, count as es, CompleteSnapshotForeignKey as et, NestedTransactionalQueryAdapter as eu, SnapshotDiagnostic as f, CheckConstraintOptions as fa, DialectNativeStorage as fc, AggregateMeta as fd, SqlNumericLike as ff, intersect as fi, canonicalLiteral as fl, CustomSource as fn, and as fo, DoUpdateAction as fr, notExists as fs, CompleteSnapshotOpaqueObject as ft, QubuTransaction as fu, SnapshotExpression as g, FieldLike as ga, PortableColumnStorage as gc, CardinalityMeta as gd, SqlText as gf, fullJoin as gi, identityColumn as gl, Source as gn, OmittableSelectClause as go, doUpdate as gr, gt as gs, CompleteSnapshotPolicy as gt, StreamableQuery as gu, SnapshotDialectExtension as h, ConstraintTiming as ha, NativeStorageDescriptor as hc, CapabilityMetadataOf as hd, SqlSemanticType as hf, crossJoin as hi, generatedColumn as hl, ProvidedSourceRow as hn, Omit$1 as ho, doNothing as hr, eq as hs, CompleteSnapshotPhysicalReference as ht, QueryExecutor as hu, SchemaSnapshotInput as i, defaultSchemaNamingPolicy as ia, ColumnStorageDeclarationOf as ic, ResultShape as id, SqlBinary as if, RecursiveCteSource as ii, IdentityGeneration as il, Query as in, PostgresIndexExtension as io, ValuesSource as ir, sum as is, CompleteSnapshotKeyConstraint as it, QubuExplainableStreamingTransactionalClient as iu, SnapshotStorageContext as j, SqliteConstraintExtension as ja, date as jc, NullabilityOf as jd, SchemaDialect as ji, AdapterExecutionResult as jl, AnyTable as jn, add as jo, MutationClause as jr, Operand as js, schemaSnapshotV1Version as jt, QueryValidationError as ju, SnapshotSpecialNumber as k, SourceConstraintsRecord as ka, columnResultValue as kc, InheritedMetadataOf as kd, SelectionSqlTypes as ki, materializeSchemaObjectIdentity as kl, exposeColumns as kn, ClausePlacement as ko, updateFrom as kr, isNull as ks, completeSchemaSnapshotVersion as kt, render as ku, SnapshotCreateResult as l, CatalogCheckExpression as la, ColumnStorageType as lc, resultValue as ld, SqlEqualityCompatible as lf, SetOperator as li, ResolvedColumnBehavior as ll, QueryWithRow as ln, index as lo, ConflictAction as lr, caseWhen as ls, CompleteSnapshotObjectOwner as lt, QubuStreamingExplainableClient as lu, SnapshotDialect as m, ConstraintOptions as ma, NativeStorage as mc, CapabilitiesOf as md, SqlOrderable as mf, unionAll as mi, externalGeneratedColumn as ml, ProvidedSourceIdentity as mn, or as mo, OnConflictClause as mr, ComparisonValidation as ms, CompleteSnapshotPartition as mt, QueryAdapter as mu, SchemaSnapshot as n, SchemaTableRegistry as na, ColumnSqlType as nc, ResultDecodingError as nd, AnySqlType as nf, SelectQuery as ni, IdentityDescriptor as nl, resolveCastTarget as nn, IndexTermOptions as no, InsertValue as nr, max as ns, CompleteSnapshotIndex as nt, QubuClient as nu, SnapshotCheckConstraint as o, schema as oa, ColumnStorageDialectOf as oc, booleanResultDecoder as od, SqlDate as of, cte as oi, IdentityOptions as ol, QueryKind as on, SourceIndexesRecord as oo, insertInto as or, SqlTag as os, CompleteSnapshotObject as ot, QubuHooks as ou, SnapshotDiagnosticCode as p, ConstraintDialectExtension as pa, NativeColumnStorage as pc, AnyFragment as pd, SqlOrderCompatible as pf, union as pi, externalDefault as pl, CustomSourceOptions as pn, not as po, ExcludedSource as pr, scalar as ps, CompleteSnapshotOwnership as pt, QubuTransactionalClient as pu, CompleteSnapshotConstraint as q, LateralIdentity as qa, ColumnDefaultInput as qc, ResultMeta as qd, schemaExpression as qi, HookOperation as ql, nullsLast as qn, concat as qo, AvailableOuterScope as qr, ColumnHasDefault as qs, PaginationPart as qt, SchemaExpressionBrand as qu, SchemaSnapshotAdapter as r, SchemaValidationError as ra, ColumnStorage as rc, ResultField as rd, SqlBigInt as rf, CteSource as ri, IdentityDialectExtension as rl, AnyQuery as rn, MysqlIndexExtension as ro, InsertValuesRow as rr, min as rs, CompleteSnapshotIndexTerm as rt, QubuExplainableClient as ru, SnapshotColumn as s, schemaNamingPolicyVersion as sa, ColumnStorageKindOf as sc, dateResultDecoder as sd, SqlDecimal as sf, recursiveCte as si, LiteralDefaultDescriptor as sl, QueryRow as sn, SqliteIndexExtension as so, insertSelect as sr, TypedSqlTag as ss, CompleteSnapshotObjectKind as st, QubuOptions as su, AnySchema as t, SchemaTableRecord as ta, ColumnOutput as tc, ResultDecoders as td, sequence as tf, SelectCardinality as ti, GeneratedDescriptor as tl, extendDialect as tn, IndexTerm as to, InsertSource as tr, countDistinct as ts, CompleteSnapshotIdentity as tt, OperationEndHook as tu, SnapshotDecodeResult as u, CatalogCheckSql as ua, ColumnStorageTypeOf as uc, timestampResultDecoder as ud, SqlInteger as uf, SetQuery as ui, SchemaLiteralValue as ul, Row as un, validateIndexDialect as uo, ConflictTarget as ur, exists as us, CompleteSnapshotObjectOwnerKind as ut, QubuStreamingTransaction as uu, SnapshotExtensionContext as v, ForeignKeyConstraint as va, PortableStorageDescriptor as vc, DependenciesOf as vd, SqlTimestamp as vf, leftJoin as vi, SchemaDialectExtension as vl, SourceConfig as vn, omit as vo, onConflict as vr, isDistinctFrom as vs, CompleteSnapshotRoutine as vt, StreamingTransactionalQueryAdapter as vu, SnapshotIndexTermExpression as w, KeyConstraintOptions as wa, StorageTypeOf as wc, GroupingMeta as wd, FromSource as wi, assertSchemaDialectSupport as wl, SourceSqlTypeMap as wn, fetchNext as wo, UpdateAssignmentValue as wr, notLike as ws, CompleteSnapshotView as wt, qubu as wu, SnapshotIdentity as x, ForeignKeyTarget as xa, StorageDescriptor as xc, FragmentMeta as xd, SqlUnknown as xf, groupBy as xi, SchemaMetadataValidationError as xl, SourceKind as xn, RowLockOptions as xo, OnDuplicateKeyUpdateClause as xr, lt as xs, CompleteSnapshotTable as xt, execute as xu, SnapshotForeignKey as y, ForeignKeyMatch as ya, PortableStorageType as yc, ExpressionMeta as yd, SqlTypeName as yf, naturalJoin as yi, SchemaDialectName as yl, SourceConstraints as yn, where as yo, IncomingColumns as yr, isNotDistinctFrom as ys, CompleteSnapshotRoutineParameter as yt, TransactionOptions as yu, schemaSnapshotVersion as z, foreignKey as za, portableStorage as zc, RenderContext as zd, SchemaRenderContext as zi, ExplainPlanRow as zl, TableRow as zn, jsonNumber as zo, MutationSqlTypes as zr, cast as zs, DialectOptions as zt, Expression as zu };