@sequenceholdings/orm 2.10.0 → 2.11.1

package/dist/index.d.ts

@@ -5,8 +5,8 @@ export { CANONICAL_FORMAT, CanonicalColumn, CanonicalEnum, CanonicalLink, Canoni
 import { CustomRolesBlock } from '@sequenceholdings/custom-roles-manifest';
 export { CustomRolesBlock, capabilityPinsSchema, customRolesBlockSchema, customRolesDeclared, parseCapabilityPin, validateCapabilityPins } from '@sequenceholdings/custom-roles-manifest';
 import { z } from 'zod';
-import { PredIr, TableMetaIr } from './ir.js';
-export { CLAIMS_CONTRACT, CMP_OPS, COMPOSED_IR_VERSION, CellSelectionIr, ClaimKey, CmpOp, CompiledArtifact, CompiledOperation, DATE_BUCKETS, DateBucket, EXTERNAL_POLICY_CLAIM_KEYS, ExternalPolicyClaimKey, GUARDED_IR_VERSION, GroupByKeyIr, INPUT_REF_KINDS, IR_VERSION, InputRefKind, IrVersionError, LEGACY_IR_VERSION, LimitIr, OrderIr, PrefetchPlanIr, RUNTIME_SQL_IR_VERSION, ResolvedMetaIr, ResolvedSourceIr, RootIr, SERVICE_PRINCIPAL_IR_VERSION, SQL_IR_VERSION, SelectionIr, ValueIr, VariableDefaultIr, VariableIr, compiledArtifactSchema, compiledOperationSchema, indexByHash, isExternalPolicyClaimKey, limitIrSchema, normalizeIr, orderIrSchema, predIrSchema, prefetchPlanIrSchema, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, rootIrSchema, selectionIrSchema, sqlObjectIrSchema, tableMetaIrSchema, usesServicePrincipal, valueIrSchema, variableDefaultIrSchema, variableIrSchema } from './ir.js';
+import { PredIr, TableMetaIr, SelectionIr } from './ir.js';
+export { CLAIMS_CONTRACT, CMP_OPS, COMPOSED_IR_VERSION, CellSelectionIr, ClaimKey, CmpOp, CompiledArtifact, CompiledOperation, DATE_BUCKETS, DateBucket, EXTERNAL_POLICY_CLAIM_KEYS, ExternalPolicyClaimKey, GUARDED_IR_VERSION, GroupByKeyIr, INPUT_REF_KINDS, IR_VERSION, InputRefKind, IrVersionError, LEGACY_IR_VERSION, LimitIr, OrderIr, PrefetchPlanIr, RUNTIME_SQL_IR_VERSION, ResolvedMetaIr, ResolvedSourceIr, RootIr, SERVICE_PRINCIPAL_IR_VERSION, SQL_IR_VERSION, ValueIr, VariableDefaultIr, VariableIr, compiledArtifactSchema, compiledOperationSchema, indexByName, isExternalPolicyClaimKey, limitIrSchema, normalizeIr, orderIrSchema, predIrSchema, prefetchPlanIrSchema, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, rootIrSchema, selectionIrSchema, sqlObjectIrSchema, tableMetaIrSchema, usesServicePrincipal, valueIrSchema, variableDefaultIrSchema, variableIrSchema } from './ir.js';
 export { e as CAPABILITY_KEY_PATTERN, C as CELLS_FIELD, a as CELL_PARTS, f as CELL_PART_SUFFIX, g as CLAIM_KEY_PATTERN, h as COLUMN_IDENTIFIER_PATTERN, i as CONSUMER_ROLE_SUFFIX, b as CellPart, D as DEFINITION_FILE_EXTENSIONS, H as HASH_DOMAIN, I as IDENTIFIER_PATTERN, M as MATERIALIZE_ACTOR, j as MATERIALIZE_CLAIMS_JSON, k as MAX_DEFINITION_FILE_BYTES, l as MAX_GENERATED_SDL_BYTES, m as MAX_IDENTIFIER_LENGTH, n as MAX_PERSISTED_READ_ROWS, o as MAX_TRACKED_COLUMN_NAME, p as NAMESPACE_CONFIG_FILENAMES, N as NAMESPACE_PATTERN, q as OPERATION_DOCUMENTS_FILE, r as OPERATION_DOCUMENTS_VERSION, O as ORM_DATA_TOKEN_HEADER, s as ORM_REGISTRATION_MAX_BYTES, t as ORM_SCHEMA_PREFIX, d as ORM_SERVICE_DATA_TOKEN_HEADER, Q as QUALIFIED_TABLE_PATTERN, R as RESERVED_COLUMN_NAMES, u as RESERVED_TABLE_NAMES, S as SYNCED_SOURCE_PATTERN, c as cellColumnName, v as consumerRoleName, w as materializeLockKey, x as materializedRefreshFunctionName, y as ormSchemaName } from './constants-D2o0vK6U.js';
 import { generateDrizzleJson } from 'drizzle-kit/api';
 import { PgTableWithColumns } from 'drizzle-orm/pg-core';
@@ -468,6 +468,52 @@ interface MigrationHints {
  */
 declare function applyMigrationHints(previous: NamespaceSnapshot, definition: NamespaceDefinition): MigrationHints;
 
+interface DeclaredSyncedIndex {
+    readonly namespace: string;
+    readonly table: string;
+    readonly name: string;
+    /** Physical column names, in key order. */
+    readonly columns: readonly string[];
+}
+/** The synced table → physical relation binding apply resolved for this environment. */
+interface SyncedIndexBacking {
+    readonly table: string;
+    readonly physicalRelation: string;
+}
+/** Every secondary index the definition declares on a synced table. */
+declare function declaredSyncedIndexes(canonical: CanonicalDefinition): DeclaredSyncedIndex[];
+/** Whether apply emitted this statement to manage a synced-table index (it must start as the applying identity). */
+declare function isSyncedIndexStatement(sql: string): boolean;
+/**
+ * Idempotent statements that converge the bound physical relations onto the
+ * declared synced indexes: first an idempotent create of the ownership ledger;
+ * then guarded drops for indexes `previous` declared that are gone, changed or
+ * rebound, on the relation they previously lived on; per declared index, a
+ * guarded drop of an owned stale copy on the same relation (invalid build,
+ * different keys or access method) and then a create-if-absent that records
+ * the new index's OID in the ledger; finally, per declared index, a check that
+ * it is the owned, declared btree on its relation (a same-named index
+ * elsewhere or one the ORM did not create fails it). The check raises 55000,
+ * which apply's idempotent-heal path never skips. Tables without a backing are
+ * skipped; apply fails earlier when a declared synced table has none.
+ */
+declare function syncedIndexStatements({ canonical, previous, backings, previousBackings, }: {
+    /** Undefined when the target definition has no synced tables left. */
+    canonical: CanonicalDefinition | undefined;
+    /** The definition the environment last applied; its removed or changed indexes are dropped. */
+    previous?: CanonicalDefinition;
+    backings: readonly SyncedIndexBacking[];
+    /** Where a table no longer bound (removed or rebound) previously lived — lets its indexes be dropped. */
+    previousBackings?: readonly SyncedIndexBacking[];
+}): string[];
+/** A declared synced index on the physical relation its table is bound to. */
+interface PlacedSyncedIndex extends DeclaredSyncedIndex {
+    readonly relation: {
+        readonly schema: string;
+        readonly table: string;
+    };
+}
+
 /**
  * Whether a kit-emitted statement is one the security pass owns (and so is
  * excluded from the convergence verdict). Exported for direct testing of the
@@ -494,6 +540,25 @@ declare function pendingKitStatementsV2({ canonical, db, }: {
     /** A drizzle PgDatabase over the target — typed loose because pushSchema's own parameter is `PgDatabase<any>`. */
     db: unknown;
 }): Promise<string[]>;
+/**
+ * Synced-index drift: the `CREATE INDEX` statements a re-apply would need
+ * because a declared index is missing from its bound physical relation (for
+ * example after the pipeline dropped and recreated the synced table), is
+ * invalid, is not a btree, was not created by the ORM for this table (no
+ * ledger row records its current OID), or no longer matches the declared key
+ * columns. Empty means every declared synced index is in place. Drizzle-kit
+ * never sees these relations, so pendingKitStatementsV2 cannot report them.
+ *
+ * Runs in one transaction: the catalog is read as the caller, then the ledger
+ * as the namespace schema's owner (a transaction-local role switch, the same
+ * one apply's statements make).
+ */
+declare function pendingSyncedIndexStatements({ canonical, backings, db, }: {
+    canonical: CanonicalDefinition;
+    backings: readonly SyncedIndexBacking[];
+    /** A drizzle PgDatabase over the target. */
+    db: unknown;
+}): Promise<string[]>;
 
 interface DrizzleEntities {
     /** The in-memory schema bag drizzle-kit snapshots (`generateDrizzleJson(imports)`). */
@@ -619,6 +684,29 @@ declare function syncedViewStatements({ definition, backings, readPolicyIrByTabl
     /** False reproduces the previous compiler solely to verify existing view definitions. */
     statementClaimChecks?: boolean;
 }): string[];
+/**
+ * Stand-in views for synced tables whose pipeline has not been deployed to
+ * this environment yet, so the rest of the namespace can still apply.
+ *
+ * Each view keeps the declared columns and types, so managed views, links,
+ * and policies that reference it still compile, and a later apply replaces it
+ * in place with the real view. Reading it raises instead of returning no
+ * rows: an empty stand-in would silently change the result of any policy that
+ * checks it (an insider exclusion would stop excluding), so the table and
+ * everything that reads it fail closed until the pipeline exists.
+ *
+ * Every column is a volatile guard call, not a typed NULL. The planner folds
+ * a constant NULL column through a dependent join or EXISTS (`NULL = x` is
+ * never true), drops the stand-in from the plan, and returns a result without
+ * ever reaching a guard in its WHERE — failing open. A volatile call cannot be
+ * folded or pruned, so any read that touches the relation raises.
+ */
+declare function syncedViewUnbackedStatements({ definition, tables, columnTypesByTable, }: {
+    definition: NamespaceDefinition;
+    tables: readonly string[];
+    /** Canonical types: the TableFile adapter downgrades enums to text, which a dependent view's type check rejects. */
+    columnTypesByTable?: ReadonlyMap<string, SyncedPredicateColumnTypes>;
+}): string[];
 /**
  * Drop synced views — idempotent cleanup for apply retries and removal.
  */
@@ -635,6 +723,25 @@ declare function syncedBackingRevokeStatements({ backings, executionOwnerRole, }
     executionOwnerRole?: string;
 }): string[];
 
+/**
+ * The contract between a disabled synced table's stand-in view, which raises
+ * when read, and the data plane, which turns that raise into a clear
+ * `OBJECT_UNAVAILABLE` instead of an opaque internal error. The message is
+ * written and parsed here so the two cannot drift.
+ */
+/** Schema-local guard every unbacked synced view calls; see `syncedViewUnbackedStatements`. */
+declare const SYNCED_BACKING_ABSENT_FUNCTION = "orm_synced_backing_absent";
+/** SQLSTATE an unbacked synced view raises: object_not_in_prerequisite_state. */
+declare const SYNCED_BACKING_ABSENT_SQLSTATE = "55000";
+/**
+ * The disabled object behind a database error, or null for any other error.
+ * 55000 alone is not enough: Postgres raises it for unrelated prerequisite
+ * failures, so the guard's own message must match too.
+ */
+declare function disabledSyncedObjectFromError(error: unknown): string | null;
+/** Caller-facing message for a disabled object. */
+declare function disabledSyncedObjectMessage(object: string): string;
+
 /**
  * Prove a stored synced view still has an exact compiler definition before
  * replacing its policy. This is deliberately narrower than SQL equivalence.
@@ -698,8 +805,10 @@ declare function generateSnapshotV2(definition: CanonicalDefinition, previousId?
  * we emit the statement ourselves and rewrite the previous snapshot to match,
  * so drizzle-kit never faces a create+drop ambiguity (its API resolves those
  * interactively — fatal in a service). Semantics mirror engine/snapshot.ts
- * applyMigrationHints exactly, plus the v2-only table-level `renamedFrom`
- * (applied FIRST, so column hints find the table under its new name).
+ * applyMigrationHints, plus two v2-only cases: the table-level `renamedFrom`
+ * (applied FIRST, so column hints find the table under its new name), and a
+ * spent rename-and-reuse column hint (v1's YAML refuses a `renamed_from` that
+ * names a column it still declares, so it never reaches its twin).
  *
  * This is a sibling of the v1 function rather than a wrapper: the v1 one is
  * keyed to `NamespaceDefinition`'s record-shaped columns and cannot express
@@ -1566,8 +1675,469 @@ declare const ormMigrationExportSchema: z.ZodObject<{
             contents: z.ZodString;
         }, z.core.$strict>>;
         client_manifest: z.ZodObject<{
-            ops_hash: z.ZodString;
-            operations: z.ZodRecord<z.ZodString, z.ZodString>;
+            operations: z.ZodRecord<z.ZodString, z.ZodObject<{
+                language: z.ZodOptional<z.ZodLiteral<"sql">>;
+                sqlQuery: z.ZodOptional<z.ZodObject<{
+                    catalog: z.ZodObject<{
+                        identity: z.ZodString;
+                        objects: z.ZodArray<z.ZodObject<{
+                            ref: z.ZodString;
+                            table: z.ZodString;
+                            columns: z.ZodArray<z.ZodObject<{
+                                name: z.ZodString;
+                                nullable: z.ZodBoolean;
+                                type: z.ZodString;
+                            }, z.core.$strip>>;
+                            scan: z.ZodString;
+                            read: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>;
+                    read: z.ZodArray<z.ZodString>;
+                    maxRows: z.ZodNumber;
+                }, z.core.$strict>>;
+                sql: z.ZodOptional<z.ZodObject<{
+                    text: z.ZodString;
+                    columns: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        type: z.ZodEnum<{
+                            bigint: "bigint";
+                            boolean: "boolean";
+                            date: "date";
+                            uuid: "uuid";
+                            text: "text";
+                            integer: "integer";
+                            numeric: "numeric";
+                            double: "double";
+                            timestamptz: "timestamptz";
+                            jsonb: "jsonb";
+                        }>;
+                        nullable: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                    parameters: z.ZodArray<z.ZodString>;
+                    read: z.ZodArray<z.ZodString>;
+                    maxRows: z.ZodNumber;
+                }, z.core.$strict>>;
+                irVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    mutation: "mutation";
+                    query: "query";
+                }>;
+                requires: z.ZodNullable<z.ZodObject<{
+                    capability: z.ZodOptional<z.ZodString>;
+                    role: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                variables: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"scalar">;
+                        scalar: z.ZodEnum<{
+                            bigint: "bigint";
+                            boolean: "boolean";
+                            date: "date";
+                            uuid: "uuid";
+                            text: "text";
+                            integer: "integer";
+                            numeric: "numeric";
+                            double: "double";
+                            timestamptz: "timestamptz";
+                            jsonb: "jsonb";
+                        }>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"enum">;
+                        name: z.ZodString;
+                        values: z.ZodArray<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"inputRef">;
+                        input: z.ZodEnum<{
+                            orderBy: "orderBy";
+                            onConflict: "onConflict";
+                            boolExp: "boolExp";
+                            selectColumn: "selectColumn";
+                            insertInput: "insertInput";
+                            setInput: "setInput";
+                            appendInput: "appendInput";
+                        }>;
+                        table: z.ZodString;
+                    }, z.core.$strip>]>;
+                    nullable: z.ZodBoolean;
+                    list: z.ZodBoolean;
+                    defaultValue: z.ZodOptional<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                tableSet: z.ZodArray<z.ZodString>;
+                roots: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"select">;
+                    alias: z.ZodString;
+                    table: z.ZodString;
+                    selection: z.ZodType<SelectionIr, unknown, z.core.$ZodTypeInternals<SelectionIr, unknown>>;
+                    where: z.ZodType<PredIr, unknown, z.core.$ZodTypeInternals<PredIr, unknown>>;
+                    orderBy: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"column">;
+                        column: z.ZodString;
+                        link: z.ZodOptional<z.ZodString>;
+                        direction: z.ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>;
+                        nulls: z.ZodOptional<z.ZodEnum<{
+                            first: "first";
+                            last: "last";
+                        }>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"dynamic">;
+                        slot: z.ZodString;
+                    }, z.core.$strip>], "kind">>>;
+                    distinctOn: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                        slot: z.ZodString;
+                    }, z.core.$strip>]>>;
+                    limit: z.ZodObject<{
+                        variable: z.ZodOptional<z.ZodString>;
+                        value: z.ZodOptional<z.ZodNumber>;
+                        default: z.ZodNumber;
+                        max: z.ZodNumber;
+                    }, z.core.$strip>;
+                    offset: z.ZodOptional<z.ZodObject<{
+                        variable: z.ZodOptional<z.ZodString>;
+                        value: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                    includeIf: z.ZodOptional<z.ZodObject<{
+                        variable: z.ZodString;
+                        negated: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                    prefetch: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        source: z.ZodString;
+                        maxStalenessMs: z.ZodOptional<z.ZodNumber>;
+                        key: z.ZodUnion<readonly [z.ZodObject<{
+                            one: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"literal">;
+                                value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"variable">;
+                                name: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"claim">;
+                                key: z.ZodEnum<{
+                                    ext_subject: "ext_subject";
+                                    ext_email: "ext_email";
+                                    sub: "sub";
+                                    org: "org";
+                                }>;
+                            }, z.core.$strip>], "kind">;
+                        }, z.core.$strip>, z.ZodObject<{
+                            many: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"literal">;
+                                value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"variable">;
+                                name: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"claim">;
+                                key: z.ZodEnum<{
+                                    ext_subject: "ext_subject";
+                                    ext_email: "ext_email";
+                                    sub: "sub";
+                                    org: "org";
+                                }>;
+                            }, z.core.$strip>], "kind">;
+                        }, z.core.$strip>]>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"byPk">;
+                    alias: z.ZodString;
+                    table: z.ZodString;
+                    selection: z.ZodType<SelectionIr, unknown, z.core.$ZodTypeInternals<SelectionIr, unknown>>;
+                    pk: z.ZodArray<z.ZodObject<{
+                        column: z.ZodString;
+                        value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"literal">;
+                            value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"variable">;
+                            name: z.ZodString;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"claim">;
+                            key: z.ZodEnum<{
+                                ext_subject: "ext_subject";
+                                ext_email: "ext_email";
+                                sub: "sub";
+                                org: "org";
+                            }>;
+                        }, z.core.$strip>], "kind">;
+                    }, z.core.$strip>>;
+                    where: z.ZodType<PredIr, unknown, z.core.$ZodTypeInternals<PredIr, unknown>>;
+                    includeIf: z.ZodOptional<z.ZodObject<{
+                        variable: z.ZodString;
+                        negated: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                    prefetch: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        source: z.ZodString;
+                        maxStalenessMs: z.ZodOptional<z.ZodNumber>;
+                        key: z.ZodUnion<readonly [z.ZodObject<{
+                            one: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"literal">;
+                                value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"variable">;
+                                name: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"claim">;
+                                key: z.ZodEnum<{
+                                    ext_subject: "ext_subject";
+                                    ext_email: "ext_email";
+                                    sub: "sub";
+                                    org: "org";
+                                }>;
+                            }, z.core.$strip>], "kind">;
+                        }, z.core.$strip>, z.ZodObject<{
+                            many: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"literal">;
+                                value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"variable">;
+                                name: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"claim">;
+                                key: z.ZodEnum<{
+                                    ext_subject: "ext_subject";
+                                    ext_email: "ext_email";
+                                    sub: "sub";
+                                    org: "org";
+                                }>;
+                            }, z.core.$strip>], "kind">;
+                        }, z.core.$strip>]>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"aggregate">;
+                    alias: z.ZodString;
+                    table: z.ZodString;
+                    where: z.ZodType<PredIr, unknown, z.core.$ZodTypeInternals<PredIr, unknown>>;
+                    count: z.ZodOptional<z.ZodObject<{
+                        columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        distinct: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    sum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    avg: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    nodes: z.ZodOptional<z.ZodType<SelectionIr, unknown, z.core.$ZodTypeInternals<SelectionIr, unknown>>>;
+                    includeIf: z.ZodOptional<z.ZodObject<{
+                        variable: z.ZodString;
+                        negated: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"aggregateGroups">;
+                    alias: z.ZodString;
+                    table: z.ZodString;
+                    where: z.ZodType<PredIr, unknown, z.core.$ZodTypeInternals<PredIr, unknown>>;
+                    groupBy: z.ZodArray<z.ZodObject<{
+                        column: z.ZodString;
+                        bucket: z.ZodOptional<z.ZodEnum<{
+                            year: "year";
+                            quarter: "quarter";
+                            month: "month";
+                            week: "week";
+                            day: "day";
+                            hour: "hour";
+                        }>>;
+                    }, z.core.$strip>>;
+                    key: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        alias: z.ZodString;
+                        column: z.ZodString;
+                    }, z.core.$strip>>>;
+                    count: z.ZodOptional<z.ZodObject<{
+                        columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        distinct: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    sum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    avg: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    limit: z.ZodObject<{
+                        variable: z.ZodOptional<z.ZodString>;
+                        value: z.ZodOptional<z.ZodNumber>;
+                        default: z.ZodNumber;
+                        max: z.ZodNumber;
+                    }, z.core.$strip>;
+                    offset: z.ZodOptional<z.ZodObject<{
+                        variable: z.ZodOptional<z.ZodString>;
+                        value: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                    includeIf: z.ZodOptional<z.ZodObject<{
+                        variable: z.ZodString;
+                        negated: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"mutation">;
+                    op: z.ZodEnum<{
+                        insert: "insert";
+                        insertOne: "insertOne";
+                        update: "update";
+                        updateByPk: "updateByPk";
+                        delete: "delete";
+                        deleteByPk: "deleteByPk";
+                        cowOverride: "cowOverride";
+                        cowRevert: "cowRevert";
+                        resolvedWrite: "resolvedWrite";
+                    }>;
+                    resolvedAction: z.ZodOptional<z.ZodEnum<{
+                        insert: "insert";
+                        update: "update";
+                        delete: "delete";
+                        revert: "revert";
+                    }>>;
+                    revertColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    writeback: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        source: z.ZodString;
+                        mode: z.ZodEnum<{
+                            sync: "sync";
+                            async: "async";
+                        }>;
+                    }, z.core.$strip>>>;
+                    localOnly: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    alias: z.ZodString;
+                    table: z.ZodString;
+                    cowSynced: z.ZodOptional<z.ZodString>;
+                    cowCopyColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    cowCopyCheck: z.ZodOptional<z.ZodType<PredIr, unknown, z.core.$ZodTypeInternals<PredIr, unknown>>>;
+                    objects: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        slot: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        rows: z.ZodArray<z.ZodArray<z.ZodObject<{
+                            column: z.ZodString;
+                            value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"literal">;
+                                value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"variable">;
+                                name: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"claim">;
+                                key: z.ZodEnum<{
+                                    ext_subject: "ext_subject";
+                                    ext_email: "ext_email";
+                                    sub: "sub";
+                                    org: "org";
+                                }>;
+                            }, z.core.$strip>], "kind">;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>]>>;
+                    pinnedColumns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        column: z.ZodString;
+                        value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"literal">;
+                            value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"variable">;
+                            name: z.ZodString;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"claim">;
+                            key: z.ZodEnum<{
+                                ext_subject: "ext_subject";
+                                ext_email: "ext_email";
+                                sub: "sub";
+                                org: "org";
+                            }>;
+                        }, z.core.$strip>], "kind">;
+                    }, z.core.$strip>>>;
+                    onConflict: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        slot: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        constraint: z.ZodString;
+                        updateColumns: z.ZodArray<z.ZodString>;
+                    }, z.core.$strip>]>>;
+                    set: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        slot: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        entries: z.ZodArray<z.ZodObject<{
+                            column: z.ZodString;
+                            value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"literal">;
+                                value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"variable">;
+                                name: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"claim">;
+                                key: z.ZodEnum<{
+                                    ext_subject: "ext_subject";
+                                    ext_email: "ext_email";
+                                    sub: "sub";
+                                    org: "org";
+                                }>;
+                            }, z.core.$strip>], "kind">;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
+                    append: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        slot: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        entries: z.ZodArray<z.ZodObject<{
+                            column: z.ZodString;
+                            value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"literal">;
+                                value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"variable">;
+                                name: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"claim">;
+                                key: z.ZodEnum<{
+                                    ext_subject: "ext_subject";
+                                    ext_email: "ext_email";
+                                    sub: "sub";
+                                    org: "org";
+                                }>;
+                            }, z.core.$strip>], "kind">;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
+                    inc: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        slot: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        entries: z.ZodArray<z.ZodObject<{
+                            column: z.ZodString;
+                            value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"literal">;
+                                value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"variable">;
+                                name: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"claim">;
+                                key: z.ZodEnum<{
+                                    ext_subject: "ext_subject";
+                                    ext_email: "ext_email";
+                                    sub: "sub";
+                                    org: "org";
+                                }>;
+                            }, z.core.$strip>], "kind">;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
+                    where: z.ZodOptional<z.ZodType<PredIr, unknown, z.core.$ZodTypeInternals<PredIr, unknown>>>;
+                    pk: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        column: z.ZodString;
+                        value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"literal">;
+                            value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"variable">;
+                            name: z.ZodString;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"claim">;
+                            key: z.ZodEnum<{
+                                ext_subject: "ext_subject";
+                                ext_email: "ext_email";
+                                sub: "sub";
+                                org: "org";
+                            }>;
+                        }, z.core.$strip>], "kind">;
+                    }, z.core.$strip>>>;
+                    insertCheck: z.ZodOptional<z.ZodType<PredIr, unknown, z.core.$ZodTypeInternals<PredIr, unknown>>>;
+                    returning: z.ZodNullable<z.ZodType<SelectionIr, unknown, z.core.$ZodTypeInternals<SelectionIr, unknown>>>;
+                    affectedRows: z.ZodDefault<z.ZodBoolean>;
+                    assertAffectedRows: z.ZodOptional<z.ZodNumber>;
+                    includeIf: z.ZodOptional<z.ZodObject<{
+                        variable: z.ZodString;
+                        negated: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>], "kind">>;
+            }, z.core.$strip>>;
         }, z.core.$strict>;
         sdl: z.ZodString;
         schema_snapshot: z.ZodJSONSchema;
@@ -1880,4 +2450,4 @@ declare function planTableImport({ definition, spec, after, }: {
     after?: string;
 }): ImportPlanResult;
 
-export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, type ActionDefinition, CAPABILITIES_CLAIM_KEY, CLAIMS_SETTING, COLUMN_TYPES, COMPARE_OPS, CanonicalDefinition, type ColumnDefault, type ColumnDefinition, type ColumnType, type CommittedChainEntry, type CommittedMigration, type CompareOp, type CompilePredIrToSqlOptions, type CompiledStatement, type DefinitionFile, type DefinitionSource, type DestructiveStatement, type DiffOptions, type DrizzleEntities, IMPORT_CONFLICT_MODES, type ImportConflictMode, type ImportPlan, type ImportPlanResult, type ImportSpec, type IndexDefinition, type JournalEntry, type LinkDefinition, type LoadedNamespace, MIGRATIONS_DIRNAME, type MigrationJournal, type MigrationWorkspace, type NamespaceCapabilities, type NamespaceConfig, type NamespaceDefinition, type NamespaceSnapshot, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, type Operand, OrmDefinitionError, type OrmMigrationExport, type ParsedPredicate, type PlannedMigration, PredIr, type Predicate, type PredicateColumnTypes, PredicateParseError, ROLES_CLAIM_KEY, type RebaseEntry, type RebaseEntryInput, type RebaseNoopOptions, STATEMENT_KINDS, SYNCED_VIEW_EXECUTION_OWNER_ROLE, type StatementKind, type SyncedBacking, type SyncedColumnType, type SyncedPredicateColumnTypes, type TableFile, TableMetaIr, type ValidatesEntry, type WrittenMigration, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, applyMigrationHints, applyMigrationHintsV2, assertSyncedViewDefinitionMatches, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalizeDefinition, capabilityExpression, castParts, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, computeDefinitionHash, convertV1DefinitionToCanonical, createOrmMigrationExport, declaredCapabilityKeys, diffCommand, diffStatements, emptyJournal, emptySnapshot, extractNamedParams, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, identifierSchema, importSpecSchema, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, migrationName, namespaceConfigSchema, namespaceSchema, normalizeSnapshot, ormMigrationExportSchema, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planCommittedMigrationV2, planMigration, planMigrationV2, planTableImport, predicateOperands, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, rewriteSyncedSourceRelationsInViewQuery, roleExpression, securityStatements, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedTables, syncedViewDropStatements, syncedViewStatements, tableFileSchema, tableReferenceSchema, typesInterfaceName, validateViewCatalogStatement, verifyRebaseIsNoop, walkPredicate, writeMigration };
+export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, type ActionDefinition, CAPABILITIES_CLAIM_KEY, CLAIMS_SETTING, COLUMN_TYPES, COMPARE_OPS, CanonicalDefinition, type ColumnDefault, type ColumnDefinition, type ColumnType, type CommittedChainEntry, type CommittedMigration, type CompareOp, type CompilePredIrToSqlOptions, type CompiledStatement, type DeclaredSyncedIndex, type DefinitionFile, type DefinitionSource, type DestructiveStatement, type DiffOptions, type DrizzleEntities, IMPORT_CONFLICT_MODES, type ImportConflictMode, type ImportPlan, type ImportPlanResult, type ImportSpec, type IndexDefinition, type JournalEntry, type LinkDefinition, type LoadedNamespace, MIGRATIONS_DIRNAME, type MigrationJournal, type MigrationWorkspace, type NamespaceCapabilities, type NamespaceConfig, type NamespaceDefinition, type NamespaceSnapshot, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, type Operand, OrmDefinitionError, type OrmMigrationExport, type ParsedPredicate, type PlacedSyncedIndex, type PlannedMigration, PredIr, type Predicate, type PredicateColumnTypes, PredicateParseError, ROLES_CLAIM_KEY, type RebaseEntry, type RebaseEntryInput, type RebaseNoopOptions, STATEMENT_KINDS, SYNCED_BACKING_ABSENT_FUNCTION, SYNCED_BACKING_ABSENT_SQLSTATE, SYNCED_VIEW_EXECUTION_OWNER_ROLE, SelectionIr, type StatementKind, type SyncedBacking, type SyncedColumnType, type SyncedIndexBacking, type SyncedPredicateColumnTypes, type TableFile, TableMetaIr, type ValidatesEntry, type WrittenMigration, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, applyMigrationHints, applyMigrationHintsV2, assertSyncedViewDefinitionMatches, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalizeDefinition, capabilityExpression, castParts, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, computeDefinitionHash, convertV1DefinitionToCanonical, createOrmMigrationExport, declaredCapabilityKeys, declaredSyncedIndexes, diffCommand, diffStatements, disabledSyncedObjectFromError, disabledSyncedObjectMessage, emptyJournal, emptySnapshot, extractNamedParams, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, identifierSchema, importSpecSchema, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSyncedIndexStatement, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, migrationName, namespaceConfigSchema, namespaceSchema, normalizeSnapshot, ormMigrationExportSchema, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, pendingSyncedIndexStatements, planCommittedMigrationV2, planMigration, planMigrationV2, planTableImport, predicateOperands, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, rewriteSyncedSourceRelationsInViewQuery, roleExpression, securityStatements, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedIndexStatements, syncedTables, syncedViewDropStatements, syncedViewStatements, syncedViewUnbackedStatements, tableFileSchema, tableReferenceSchema, typesInterfaceName, validateViewCatalogStatement, verifyRebaseIsNoop, walkPredicate, writeMigration };