@sequenceholdings/orm 2.1.0 → 2.2.0

package/dist/index.d.ts

@@ -1,13 +1,16 @@
-export { AuthoringContext, AuthoringRegistration, COLUMN_BRAND, COLUMN_DEFAULT_FNS, ColumnBuilder, ColumnDefaultFn, ColumnDefaultLiteral, ColumnTypeSpec, CowMutationInput, DrizzleRelation, ENUM_BRAND, EnumRef, ForeignKeyInput, IndexInput, LINK_BRAND, LinkKind, LoadNamespaceOptions, LoadedNamespaceV2, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NamespaceCapabilitiesInput, NamespaceConfigInput, ORM_TO_PIPELINE_TYPE, OrmContractColumnMap, OrmContractPipelineColumn, OrmSyncedTableContract, OrmToPipelineType, OverlayTableRef, OverlayWinsUnionInput, OverrideRowMutationInput, PolicyInput, PolicyVariantInput, PolicyWithVariantsInput, RelationRef, RevertOverlayMutationInput, SCHEMA_DIR, SYNCED_CONTRACT_HASH_DOMAIN, SeqLink, SeqNamespaceConfig, SeqTable, SeqView, SerializeNamespaceInput, SyncedTableConfig, SyncedTablePoliciesInput, TABLE_BRAND, TableConfig, TablePoliciesInput, TableRef, ToManyOptions, ToOneOptions, ToPlatformUserOptions, TypedSyncedTableConfig, VIEW_BRAND, ViewConfig, ViewPoliciesInput, ViewQueryContext, ViewSelectQuery, activeAuthoringContext, beginAuthoringContext, computeCanonicalHash, computeSyncedContractHash, defineEnum, defineNamespace, defineSyncedTable, defineTable, defineView, deriveColumnName, endAuthoringContext, extractOrmSyncedTableContract, isColumnBuilder, isEnumRef, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, loadNamespaceFromDir, overlayWinsUnion, overrideRowMutation, revertOverlayMutation, serializeNamespace, syncedContractSurface, t, toMany, toOne, toPlatformUser } from './authoring.js';
+export { AuthoringContext, AuthoringRegistration, COLUMN_BRAND, COLUMN_DEFAULT_FNS, CatalogFolders, CheckInput, ColumnBuilder, ColumnDefaultFn, ColumnDefaultLiteral, ColumnTypeSpec, Comparator, CowMutationInput, DrizzleRelation, DurationInput, ENUM_BRAND, EnumRef, EtlSourceInput, ExternalObjectRef, ForeignKeyInput, FunctionRef, IndexInput, LINK_BRAND, LinkKind, LoadNamespaceOptions, LoadedNamespaceV2, ManualSourceInput, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NamespaceCapabilitiesInput, NamespaceCatalog, NamespaceConfigInput, ORM_TO_PIPELINE_TYPE, OrmContractColumnMap, OrmContractPipelineColumn, OrmSyncedTableContract, OrmToPipelineType, OverlayTableRef, OverlayWinsUnionInput, OverrideRowMutationInput, PolicyInput, PolicyVariantInput, PolicyWithVariantsInput, PrefetchSourceInput, ReferentialAction, RelationRef, ResolvedSourceInput, ResolvedTableConfig, ResolvedTablePoliciesInput, RevertOverlayMutationInput, SCHEMA_DIR, SYNCED_CONTRACT_HASH_DOMAIN, SeqLink, SeqNamespaceConfig, SeqTable, SeqView, SerializeNamespaceInput, SyncedTableConfig, SyncedTablePoliciesInput, TABLE_BRAND, TableConfig, TablePoliciesInput, TableRef, ToManyOptions, ToOneOptions, ToPlatformUserOptions, TypedSyncedTableConfig, VIEW_BRAND, ViewConfig, ViewPoliciesInput, ViewQueryContext, ViewSelectQuery, activeAuthoringContext, beginAuthoringContext, computeCanonicalHash, computeSyncedContractHash, custom, defineEnum, defineNamespace, defineResolvedTable, defineSyncedTable, defineTable, defineView, deriveColumnName, endAuthoringContext, etlSource, extractOrmSyncedTableContract, highest, isColumnBuilder, isEnumRef, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, latest, loadNamespaceFromDir, lowest, managedFn, manualSource, nonNullFirst, objectRef, overlayWinsUnion, overrideRowMutation, prefetchSource, priority, revertOverlayMutation, serializeNamespace, syncedContractSurface, t, toMany, toOne, toPlatformUser, validateNamespaceCatalog } from './authoring.js';
+export { S as SqlOperationDefinition, d as defineOperation } from './definition-DjfC7Lll.js';
 import { CanonicalDefinition } from './canonical.js';
-export { CANONICAL_FORMAT, CanonicalColumn, CanonicalEnum, CanonicalLink, CanonicalTable, CanonicalView, IDENTIFIER_RE, PolicyExpression, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, normalizeCanonical, policyExpressionSchema, policyVariantSchema } from './canonical.js';
+export { CANONICAL_FORMAT, CanonicalColumn, CanonicalEnum, CanonicalLink, CanonicalTable, CanonicalView, IDENTIFIER_RE, OntologyContract, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, normalizeCanonical, ontologyContractSchema, readOntologyContract } from './canonical.js';
 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 } from './ir.js';
-export { CLAIMS_CONTRACT, CMP_OPS, ClaimKey, CmpOp, CompiledArtifact, CompiledOperation, DATE_BUCKETS, DateBucket, GroupByKeyIr, INPUT_REF_KINDS, IR_VERSION, InputRefKind, IrVersionError, LEGACY_IR_VERSION, LimitIr, OrderIr, RootIr, SelectionIr, TableMetaIr, ValueIr, VariableDefaultIr, VariableIr, compiledArtifactSchema, compiledOperationSchema, indexByHash, limitIrSchema, normalizeIr, orderIrSchema, predIrSchema, requiredArtifactIrVersion, rootIrSchema, selectionIrSchema, tableMetaIrSchema, valueIrSchema, variableDefaultIrSchema, variableIrSchema } from './ir.js';
+export { CLAIMS_CONTRACT, CMP_OPS, COMPOSED_IR_VERSION, CellSelectionIr, ClaimKey, CmpOp, CompiledArtifact, CompiledOperation, DATE_BUCKETS, DateBucket, GUARDED_IR_VERSION, GroupByKeyIr, INPUT_REF_KINDS, IR_VERSION, InputRefKind, IrVersionError, LEGACY_IR_VERSION, LimitIr, OrderIr, PrefetchPlanIr, RUNTIME_SQL_IR_VERSION, ResolvedMetaIr, ResolvedSourceIr, RootIr, SQL_IR_VERSION, SelectionIr, TableMetaIr, ValueIr, VariableDefaultIr, VariableIr, compiledArtifactSchema, compiledOperationSchema, indexByHash, limitIrSchema, normalizeIr, orderIrSchema, predIrSchema, prefetchPlanIrSchema, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, rootIrSchema, selectionIrSchema, tableMetaIrSchema, 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_TRACKED_COLUMN_NAME, o as NAMESPACE_CONFIG_FILENAMES, N as NAMESPACE_PATTERN, O as ORM_DATA_TOKEN_HEADER, p as ORM_REGISTRATION_MAX_BYTES, q as ORM_SCHEMA_PREFIX, d as ORM_SERVICE_DATA_TOKEN_HEADER, Q as QUALIFIED_TABLE_PATTERN, R as RESERVED_COLUMN_NAMES, r as RESERVED_TABLE_NAMES, S as SYNCED_SOURCE_PATTERN, c as cellColumnName, s as consumerRoleName, t as materializeLockKey, u as materializedRefreshFunctionName, v as ormSchemaName } from './constants-C6EG6Wq7.js';
 import { generateDrizzleJson } from 'drizzle-kit/api';
 import { PgTableWithColumns } from 'drizzle-orm/pg-core';
+export { P as PolicyExpression, p as policyExpressionSchema, a as policyVariantSchema } from './policy-1iZbGnZZ.js';
 import 'drizzle-orm';
 import 'drizzle-orm/query-builders/query-builder';
 
@@ -49,14 +52,14 @@ declare const actionParamSchema: z.ZodObject<{
     type: z.ZodEnum<{
         bigint: "bigint";
         boolean: "boolean";
-        uuid: "uuid";
+        date: "date";
         text: "text";
+        timestamptz: "timestamptz";
+        jsonb: "jsonb";
+        uuid: "uuid";
         integer: "integer";
         numeric: "numeric";
         double: "double";
-        timestamptz: "timestamptz";
-        date: "date";
-        jsonb: "jsonb";
     }>;
     optional: z.ZodOptional<z.ZodBoolean>;
     description: z.ZodOptional<z.ZodString>;
@@ -74,14 +77,14 @@ declare const actionSchema: z.ZodObject<{
         type: z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
+            date: "date";
             text: "text";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            date: "date";
-            jsonb: "jsonb";
         }>;
         optional: z.ZodOptional<z.ZodBoolean>;
         description: z.ZodOptional<z.ZodString>;
@@ -91,14 +94,14 @@ declare const actionSchema: z.ZodObject<{
     returns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
         bigint: "bigint";
         boolean: "boolean";
-        uuid: "uuid";
+        date: "date";
         text: "text";
+        timestamptz: "timestamptz";
+        jsonb: "jsonb";
+        uuid: "uuid";
         integer: "integer";
         numeric: "numeric";
         double: "double";
-        timestamptz: "timestamptz";
-        date: "date";
-        jsonb: "jsonb";
     }>>>;
     audit: z.ZodOptional<z.ZodObject<{
         action: z.ZodEnum<{
@@ -126,14 +129,14 @@ type ColumnType = (typeof COLUMN_TYPES)[number];
 declare const columnTypeSchema: z.ZodEnum<{
     bigint: "bigint";
     boolean: "boolean";
-    uuid: "uuid";
+    date: "date";
     text: "text";
+    timestamptz: "timestamptz";
+    jsonb: "jsonb";
+    uuid: "uuid";
     integer: "integer";
     numeric: "numeric";
     double: "double";
-    timestamptz: "timestamptz";
-    date: "date";
-    jsonb: "jsonb";
 }>;
 /**
  * True when the default is one of the allowlisted SQL function calls for its
@@ -158,14 +161,14 @@ declare const columnSchema: z.ZodObject<{
     type: z.ZodEnum<{
         bigint: "bigint";
         boolean: "boolean";
-        uuid: "uuid";
+        date: "date";
         text: "text";
+        timestamptz: "timestamptz";
+        jsonb: "jsonb";
+        uuid: "uuid";
         integer: "integer";
         numeric: "numeric";
         double: "double";
-        timestamptz: "timestamptz";
-        date: "date";
-        jsonb: "jsonb";
     }>;
     primary_key: z.ZodOptional<z.ZodBoolean>;
     nullable: z.ZodOptional<z.ZodBoolean>;
@@ -208,14 +211,14 @@ declare const tableFileSchema: z.ZodObject<{
         type: z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
+            date: "date";
             text: "text";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            date: "date";
-            jsonb: "jsonb";
         }>;
         primary_key: z.ZodOptional<z.ZodBoolean>;
         nullable: z.ZodOptional<z.ZodBoolean>;
@@ -259,14 +262,14 @@ declare const tableFileSchema: z.ZodObject<{
             type: z.ZodEnum<{
                 bigint: "bigint";
                 boolean: "boolean";
-                uuid: "uuid";
+                date: "date";
                 text: "text";
+                timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
                 integer: "integer";
                 numeric: "numeric";
                 double: "double";
-                timestamptz: "timestamptz";
-                date: "date";
-                jsonb: "jsonb";
             }>;
             optional: z.ZodOptional<z.ZodBoolean>;
             description: z.ZodOptional<z.ZodString>;
@@ -276,14 +279,14 @@ declare const tableFileSchema: z.ZodObject<{
         returns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
+            date: "date";
             text: "text";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            date: "date";
-            jsonb: "jsonb";
         }>>>;
         audit: z.ZodOptional<z.ZodObject<{
             action: z.ZodEnum<{
@@ -358,6 +361,11 @@ type SyncedColumnType = ColumnType | {
 };
 type SyncedPredicateColumnTypes = Readonly<Record<string, SyncedColumnType>>;
 interface CompilePredIrToSqlOptions {
+    readonly alias?: string;
+    readonly exists?: (predicate: Extract<PredIr, {
+        kind: 'exists';
+    }>) => string;
+    readonly namespace?: string;
     /** Column name → declared type, for claim casts in comparisons. */
     readonly columnTypes?: SyncedPredicateColumnTypes;
     /** Logical column name → physical column name for the synced backing. */
@@ -423,74 +431,9 @@ declare const ROLES_CLAIM_KEY = "roles";
 declare const quoteIdentifier: (name: string) => string;
 declare const quoteLiteral: (value: string) => string;
 declare const claimExpression: (key: string) => string;
-/** NULL claims (or a missing capabilities array) coalesce to false — capability checks fail closed. */
-declare const capabilityExpression: (key: string) => string;
+declare const capabilityExpression: (key: string, namespace?: string) => string;
 /** NULL claims (or a missing roles array) coalesce to false — role checks fail closed. */
-declare const roleExpression: (key: string) => string;
-
-/** Namespace names become Postgres identifiers (`orm_<ns>` schema, `orm_<ns>_consumer` role) — the tight grammar is a security control, not cosmetics. */
-declare const NAMESPACE_PATTERN: RegExp;
-declare const IDENTIFIER_PATTERN: RegExp;
-/** Native source columns may have one leading underscore; relation names may not. */
-declare const COLUMN_IDENTIFIER_PATTERN: RegExp;
-declare const MAX_IDENTIFIER_LENGTH = 63;
-/**
- * The Data API carries a delegated, attenuated data token on this header (not
- * `Authorization`, which stays the app-user/session bearer). One definition
- * shared by the client transport, the server's caller resolver, and the
- * function-invoke minter, so all three agree.
- */
-declare const ORM_DATA_TOKEN_HEADER = "x-sequence-data-token";
-/**
- * The SEPARATE header the invoke proxy uses to hand a managed function its
- * *service* data token — the escalation path. A function receives BOTH this and
- * `ORM_DATA_TOKEN_HEADER`; the default `createOrmClient` reads the user token,
- * the deliberately-named `createServiceOrmClient` reads THIS one. Two distinct
- * headers so reaching for the service identity is always an explicit act, never
- * an accidental default. Both are sent to the Data API on `ORM_DATA_TOKEN_HEADER`
- * — the server stays mode-agnostic and resolves whatever sub the token carries.
- */
-declare const ORM_SERVICE_DATA_TOKEN_HEADER = "x-sequence-data-token-service";
-/**
- * Custom Roles & Capabilities claim keys as policies reference them: a
- * host-scoped registry key, or an org pin's `org/<key>`. Matches the registry
- * key grammar EXACTLY (`[a-z0-9-]`, 1–64 chars, no `_` — the FGA object-id
- * delimiter) so any capability that's declarable/attachable in namespace.yaml
- * can also be referenced here — a stricter pattern would let a valid key
- * register yet fail at apply (e.g. `org/2fa`, a one-char or digit-led key).
- */
-declare const CAPABILITY_KEY_PATTERN: RegExp;
-declare const CLAIM_KEY_PATTERN: RegExp;
-/** Qualified reference to a table outside the defining file: `<schema>.<table>`. */
-declare const QUALIFIED_TABLE_PATTERN: RegExp;
-/** Synced reflected sources are restricted to the gold layer. */
-declare const SYNCED_SOURCE_PATTERN: RegExp;
-declare const ORM_SCHEMA_PREFIX = "orm_";
-declare const CONSUMER_ROLE_SUFFIX = "_consumer";
-declare const ormSchemaName: (namespace: string) => string;
-declare const consumerRoleName: (namespace: string) => string;
-declare const DEFINITION_FILE_EXTENSIONS: readonly [".yml", ".yaml"];
-/** Reserved basenames for the namespace-level config file (description, org capability pins). */
-declare const NAMESPACE_CONFIG_FILENAMES: Set<string>;
-declare const HASH_DOMAIN = "sequence-orm-definitions\0";
-/**
- * A per-file byte cap where the loader reads untrusted YAML into memory — a real failure mode, not a product
- * limit. Counts of tables/indexes/params and policy/SQL lengths are
- * deliberately uncapped; Postgres enforces its own limits loudly at apply.
- */
-declare const MAX_DEFINITION_FILE_BYTES: number;
-/** Generated SDL aggregates every table/view; it is not an individual source file. */
-declare const MAX_GENERATED_SDL_BYTES: number;
-/** Registration and reviewed exports carry SDL, canonical metadata, snapshots and migrations. */
-declare const ORM_REGISTRATION_MAX_BYTES: number;
-/** `/api/data/<ns>/actions/…` and `/api/data/<ns>/query` share the table path segment. */
-declare const RESERVED_TABLE_NAMES: Set<string>;
-/**
- * The Data API's query-string grammar owns these parameter names — a column
- * with one of them could never be filtered over the wire, so definitions
- * refuse it up front ("validate rejects only what can never work").
- */
-declare const RESERVED_COLUMN_NAMES: Set<string>;
+declare const roleExpression: (key: string, namespace?: string) => string;
 
 /** drizzle-kit's serialized schema — the diff/replay artifact the registry stores. */
 type NamespaceSnapshot = ReturnType<typeof generateDrizzleJson>;
@@ -741,11 +684,32 @@ declare function applyMigrationHintsV2(previous: NamespaceSnapshot, definition:
  * action function statements. v2 enforces row policies inside compiled
  * operations (no PG RLS policies) and executes actions on the data plane
  * (no plpgsql functions), so a v2 plan is hints + kit DDL only.
+ *
+ * Managed views are dropped and recreated only when the migration reaches
+ * them: their own definition changed, they read a relation whose change is not
+ * provably view-safe, or they depend on a view that is recreated. Every other
+ * view stays in place, keeping its grants, owner, and outside dependents.
  */
-declare function planMigrationV2({ canonical, previousSnapshot, }: {
+declare function planMigrationV2(input: {
     canonical: CanonicalDefinition;
     previousSnapshot?: NamespaceSnapshot;
 }): Promise<PlannedMigration>;
+/**
+ * The plan a committed (reviewed) migration was authored as: the current
+ * planner when it reproduces the migration, otherwise the legacy one for a
+ * migration written before view recreation was narrowed. `reproduces` decides
+ * a match — rendered SQL for the CLI's tip gate, statement lists for Atlas's
+ * replay gate. When neither reproduces it, the current plan comes back with
+ * `reproduced: false`, so callers report the mismatch exactly as before.
+ */
+declare function planCommittedMigrationV2({ canonical, previousSnapshot, reproduces, }: {
+    canonical: CanonicalDefinition;
+    previousSnapshot?: NamespaceSnapshot;
+    reproduces: (plan: PlannedMigration) => boolean;
+}): Promise<{
+    plan: PlannedMigration;
+    reproduced: boolean;
+}>;
 /**
  * Drizzle's manual-view snapshot stores declared columns, but PostgreSQL names
  * and types the live view from the SELECT itself. Assert the live catalog in
@@ -797,6 +761,7 @@ declare const ormMigrationExportSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             tables: z.ZodArray<z.ZodObject<{
                 table: z.ZodString;
+                displayName: z.ZodOptional<z.ZodString>;
                 description: z.ZodOptional<z.ZodString>;
                 renamedFrom: z.ZodOptional<z.ZodString>;
                 source: z.ZodOptional<z.ZodString>;
@@ -806,14 +771,14 @@ declare const ormMigrationExportSchema: z.ZodObject<{
                     type: z.ZodUnion<readonly [z.ZodEnum<{
                         bigint: "bigint";
                         boolean: "boolean";
-                        uuid: "uuid";
+                        date: "date";
                         text: "text";
+                        timestamptz: "timestamptz";
+                        jsonb: "jsonb";
+                        uuid: "uuid";
                         integer: "integer";
                         numeric: "numeric";
                         double: "double";
-                        timestamptz: "timestamptz";
-                        date: "date";
-                        jsonb: "jsonb";
                     }>, z.ZodObject<{
                         enum: z.ZodString;
                     }, z.core.$strip>]>;
@@ -831,6 +796,16 @@ declare const ormMigrationExportSchema: z.ZodObject<{
                     renamedFrom: z.ZodOptional<z.ZodString>;
                     cast: z.ZodOptional<z.ZodString>;
                     deprecated: z.ZodDefault<z.ZodBoolean>;
+                    cell: z.ZodOptional<z.ZodObject<{
+                        of: z.ZodString;
+                        part: z.ZodEnum<{
+                            at: "at";
+                            by: "by";
+                            rev: "rev";
+                            source: "source";
+                            conflicts: "conflicts";
+                        }>;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>>>;
                 primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 links: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -841,9 +816,24 @@ declare const ormMigrationExportSchema: z.ZodObject<{
                         toPlatformUser: "toPlatformUser";
                     }>;
                     target: z.ZodOptional<z.ZodString>;
+                    namespace: z.ZodOptional<z.ZodString>;
                     on: z.ZodString;
                     references: z.ZodOptional<z.ZodString>;
                     enforce: z.ZodDefault<z.ZodBoolean>;
+                    onDelete: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
+                    onUpdate: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
                     description: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>>;
                 indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -851,6 +841,10 @@ declare const ormMigrationExportSchema: z.ZodObject<{
                     unique: z.ZodDefault<z.ZodBoolean>;
                     name: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>>;
+                checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    expression: z.ZodString;
+                }, z.core.$strict>>>;
                 policies: z.ZodDefault<z.ZodObject<{
                     read: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                         default: z.ZodString;
@@ -892,14 +886,14 @@ declare const ormMigrationExportSchema: z.ZodObject<{
                         type: z.ZodEnum<{
                             bigint: "bigint";
                             boolean: "boolean";
-                            uuid: "uuid";
+                            date: "date";
                             text: "text";
+                            timestamptz: "timestamptz";
+                            jsonb: "jsonb";
+                            uuid: "uuid";
                             integer: "integer";
                             numeric: "numeric";
                             double: "double";
-                            timestamptz: "timestamptz";
-                            date: "date";
-                            jsonb: "jsonb";
                         }>;
                         nullable: z.ZodDefault<z.ZodBoolean>;
                     }, z.core.$strip>>>;
@@ -934,7 +928,24 @@ declare const ormMigrationExportSchema: z.ZodObject<{
                         "initially-immediate": "initially-immediate";
                         "initially-deferred": "initially-deferred";
                     }>>;
+                    onDelete: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
+                    onUpdate: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
                 }, z.core.$strict>>>;
+                cellMetadata: z.ZodOptional<z.ZodLiteral<true>>;
+                internal: z.ZodOptional<z.ZodLiteral<true>>;
+                materializes: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
             views: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 view: z.ZodString;
@@ -945,14 +956,14 @@ declare const ormMigrationExportSchema: z.ZodObject<{
                     type: z.ZodUnion<readonly [z.ZodEnum<{
                         bigint: "bigint";
                         boolean: "boolean";
-                        uuid: "uuid";
+                        date: "date";
                         text: "text";
+                        timestamptz: "timestamptz";
+                        jsonb: "jsonb";
+                        uuid: "uuid";
                         integer: "integer";
                         numeric: "numeric";
                         double: "double";
-                        timestamptz: "timestamptz";
-                        date: "date";
-                        jsonb: "jsonb";
                     }>, z.ZodObject<{
                         enum: z.ZodString;
                     }, z.core.$strip>]>;
@@ -970,6 +981,16 @@ declare const ormMigrationExportSchema: z.ZodObject<{
                     renamedFrom: z.ZodOptional<z.ZodString>;
                     cast: z.ZodOptional<z.ZodString>;
                     deprecated: z.ZodDefault<z.ZodBoolean>;
+                    cell: z.ZodOptional<z.ZodObject<{
+                        of: z.ZodString;
+                        part: z.ZodEnum<{
+                            at: "at";
+                            by: "by";
+                            rev: "rev";
+                            source: "source";
+                            conflicts: "conflicts";
+                        }>;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>>;
                 primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 links: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -980,9 +1001,24 @@ declare const ormMigrationExportSchema: z.ZodObject<{
                         toPlatformUser: "toPlatformUser";
                     }>;
                     target: z.ZodOptional<z.ZodString>;
+                    namespace: z.ZodOptional<z.ZodString>;
                     on: z.ZodString;
                     references: z.ZodOptional<z.ZodString>;
                     enforce: z.ZodDefault<z.ZodBoolean>;
+                    onDelete: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
+                    onUpdate: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
                     description: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>>;
                 policies: z.ZodObject<{
@@ -997,11 +1033,501 @@ declare const ormMigrationExportSchema: z.ZodObject<{
                 }, z.core.$strict>;
                 query: z.ZodString;
                 dependencies: z.ZodArray<z.ZodString>;
+                resolved: z.ZodOptional<z.ZodObject<{
+                    sources: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            manual: "manual";
+                            prefetch: "prefetch";
+                            etl: "etl";
+                        }>;
+                        table: z.ZodString;
+                        columns: z.ZodArray<z.ZodString>;
+                        updatedAt: z.ZodOptional<z.ZodString>;
+                        key: z.ZodOptional<z.ZodString>;
+                        fetch: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                            shape: z.ZodLiteral<"single">;
+                        }, z.core.$strict>, z.ZodObject<{
+                            shape: z.ZodLiteral<"batch">;
+                            maxKeys: z.ZodNumber;
+                        }, z.core.$strict>]>>;
+                        function: z.ZodOptional<z.ZodObject<{
+                            kind: z.ZodEnum<{
+                                managed: "managed";
+                                native: "native";
+                            }>;
+                            id: z.ZodString;
+                        }, z.core.$strict>>;
+                        prefetchDefaults: z.ZodOptional<z.ZodObject<{
+                            maxStalenessMs: z.ZodNumber;
+                            timeoutMs: z.ZodNumber;
+                            onError: z.ZodEnum<{
+                                fallback: "fallback";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strict>>;
+                        writeback: z.ZodOptional<z.ZodObject<{
+                            columns: z.ZodArray<z.ZodString>;
+                            defaultMode: z.ZodEnum<{
+                                sync: "sync";
+                                async: "async";
+                            }>;
+                            timeoutMs: z.ZodNumber;
+                            clearManualOnConfirm: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    resolve: z.ZodArray<z.ZodObject<{
+                        column: z.ZodString;
+                        comparator: z.ZodEnum<{
+                            custom: "custom";
+                            latest: "latest";
+                            highest: "highest";
+                            lowest: "lowest";
+                            priority: "priority";
+                            nonNullFirst: "nonNullFirst";
+                        }>;
+                        candidates: z.ZodArray<z.ZodString>;
+                        orderBy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    deletedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    materialized: z.ZodOptional<z.ZodObject<{
+                        table: z.ZodString;
+                        compute: z.ZodString;
+                    }, z.core.$strict>>;
+                    policies: z.ZodDefault<z.ZodObject<{
+                        write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>>;
+                        insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>>;
+                        update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                internal: z.ZodOptional<z.ZodLiteral<true>>;
             }, z.core.$strip>>>;
+            exports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                read: z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                    capability: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    role: z.ZodString;
+                }, z.core.$strict>]>;
+                write: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                    capability: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    role: z.ZodString;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>>;
             capabilities: z.ZodDefault<z.ZodObject<{
                 roles: z.ZodOptional<z.ZodUnknown>;
                 uses: z.ZodDefault<z.ZodArray<z.ZodString>>;
             }, z.core.$strip>>;
+            imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                definition_format: z.ZodLiteral<2>;
+                namespace: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                enums: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    values: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>>>;
+                tables: z.ZodArray<z.ZodObject<{
+                    table: z.ZodString;
+                    displayName: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    renamedFrom: z.ZodOptional<z.ZodString>;
+                    source: z.ZodOptional<z.ZodString>;
+                    columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        columnName: z.ZodString;
+                        type: z.ZodUnion<readonly [z.ZodEnum<{
+                            bigint: "bigint";
+                            boolean: "boolean";
+                            date: "date";
+                            text: "text";
+                            timestamptz: "timestamptz";
+                            jsonb: "jsonb";
+                            uuid: "uuid";
+                            integer: "integer";
+                            numeric: "numeric";
+                            double: "double";
+                        }>, z.ZodObject<{
+                            enum: z.ZodString;
+                        }, z.core.$strip>]>;
+                        nullable: z.ZodDefault<z.ZodBoolean>;
+                        unique: z.ZodDefault<z.ZodBoolean>;
+                        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+                        defaultFn: z.ZodOptional<z.ZodEnum<{
+                            "gen_random_uuid()": "gen_random_uuid()";
+                            "now()": "now()";
+                        }>>;
+                        onUpdateFn: z.ZodOptional<z.ZodEnum<{
+                            "now()": "now()";
+                        }>>;
+                        description: z.ZodOptional<z.ZodString>;
+                        renamedFrom: z.ZodOptional<z.ZodString>;
+                        cast: z.ZodOptional<z.ZodString>;
+                        deprecated: z.ZodDefault<z.ZodBoolean>;
+                        cell: z.ZodOptional<z.ZodObject<{
+                            of: z.ZodString;
+                            part: z.ZodEnum<{
+                                at: "at";
+                                by: "by";
+                                rev: "rev";
+                                source: "source";
+                                conflicts: "conflicts";
+                            }>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strip>>>;
+                    primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            toOne: "toOne";
+                            toMany: "toMany";
+                            toPlatformUser: "toPlatformUser";
+                        }>;
+                        target: z.ZodOptional<z.ZodString>;
+                        namespace: z.ZodOptional<z.ZodString>;
+                        on: z.ZodString;
+                        references: z.ZodOptional<z.ZodString>;
+                        enforce: z.ZodDefault<z.ZodBoolean>;
+                        onDelete: z.ZodOptional<z.ZodEnum<{
+                            cascade: "cascade";
+                            restrict: "restrict";
+                            "no action": "no action";
+                            "set null": "set null";
+                            "set default": "set default";
+                        }>>;
+                        onUpdate: z.ZodOptional<z.ZodEnum<{
+                            cascade: "cascade";
+                            restrict: "restrict";
+                            "no action": "no action";
+                            "set null": "set null";
+                            "set default": "set default";
+                        }>>;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                    indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        columns: z.ZodArray<z.ZodString>;
+                        unique: z.ZodDefault<z.ZodBoolean>;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        expression: z.ZodString;
+                    }, z.core.$strict>>>;
+                    policies: z.ZodDefault<z.ZodObject<{
+                        read: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>>;
+                        write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>>;
+                        insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>>;
+                        update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strip>>;
+                    actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        requires: z.ZodOptional<z.ZodString>;
+                        params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            type: z.ZodEnum<{
+                                bigint: "bigint";
+                                boolean: "boolean";
+                                date: "date";
+                                text: "text";
+                                timestamptz: "timestamptz";
+                                jsonb: "jsonb";
+                                uuid: "uuid";
+                                integer: "integer";
+                                numeric: "numeric";
+                                double: "double";
+                            }>;
+                            nullable: z.ZodDefault<z.ZodBoolean>;
+                        }, z.core.$strip>>>;
+                        executes: z.ZodString;
+                        returns: z.ZodDefault<z.ZodEnum<{
+                            rows: "rows";
+                            rowsAffected: "rowsAffected";
+                            scalar: "scalar";
+                        }>>;
+                        audit: z.ZodOptional<z.ZodObject<{
+                            action: z.ZodString;
+                            resource: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>>;
+                    cowMutations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            override: "override";
+                            revert: "revert";
+                        }>;
+                        name: z.ZodString;
+                        synced: z.ZodString;
+                        pk: z.ZodString;
+                        copy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        set: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>>;
+                    foreignKeys: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        columns: z.ZodArray<z.ZodString>;
+                        target: z.ZodString;
+                        references: z.ZodArray<z.ZodString>;
+                        deferrable: z.ZodOptional<z.ZodEnum<{
+                            "initially-immediate": "initially-immediate";
+                            "initially-deferred": "initially-deferred";
+                        }>>;
+                        onDelete: z.ZodOptional<z.ZodEnum<{
+                            cascade: "cascade";
+                            restrict: "restrict";
+                            "no action": "no action";
+                            "set null": "set null";
+                            "set default": "set default";
+                        }>>;
+                        onUpdate: z.ZodOptional<z.ZodEnum<{
+                            cascade: "cascade";
+                            restrict: "restrict";
+                            "no action": "no action";
+                            "set null": "set null";
+                            "set default": "set default";
+                        }>>;
+                    }, z.core.$strict>>>;
+                    cellMetadata: z.ZodOptional<z.ZodLiteral<true>>;
+                    internal: z.ZodOptional<z.ZodLiteral<true>>;
+                    materializes: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                views: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    view: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    columns: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        columnName: z.ZodString;
+                        type: z.ZodUnion<readonly [z.ZodEnum<{
+                            bigint: "bigint";
+                            boolean: "boolean";
+                            date: "date";
+                            text: "text";
+                            timestamptz: "timestamptz";
+                            jsonb: "jsonb";
+                            uuid: "uuid";
+                            integer: "integer";
+                            numeric: "numeric";
+                            double: "double";
+                        }>, z.ZodObject<{
+                            enum: z.ZodString;
+                        }, z.core.$strip>]>;
+                        nullable: z.ZodDefault<z.ZodBoolean>;
+                        unique: z.ZodDefault<z.ZodBoolean>;
+                        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+                        defaultFn: z.ZodOptional<z.ZodEnum<{
+                            "gen_random_uuid()": "gen_random_uuid()";
+                            "now()": "now()";
+                        }>>;
+                        onUpdateFn: z.ZodOptional<z.ZodEnum<{
+                            "now()": "now()";
+                        }>>;
+                        description: z.ZodOptional<z.ZodString>;
+                        renamedFrom: z.ZodOptional<z.ZodString>;
+                        cast: z.ZodOptional<z.ZodString>;
+                        deprecated: z.ZodDefault<z.ZodBoolean>;
+                        cell: z.ZodOptional<z.ZodObject<{
+                            of: z.ZodString;
+                            part: z.ZodEnum<{
+                                at: "at";
+                                by: "by";
+                                rev: "rev";
+                                source: "source";
+                                conflicts: "conflicts";
+                            }>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strip>>;
+                    primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            toOne: "toOne";
+                            toMany: "toMany";
+                            toPlatformUser: "toPlatformUser";
+                        }>;
+                        target: z.ZodOptional<z.ZodString>;
+                        namespace: z.ZodOptional<z.ZodString>;
+                        on: z.ZodString;
+                        references: z.ZodOptional<z.ZodString>;
+                        enforce: z.ZodDefault<z.ZodBoolean>;
+                        onDelete: z.ZodOptional<z.ZodEnum<{
+                            cascade: "cascade";
+                            restrict: "restrict";
+                            "no action": "no action";
+                            "set null": "set null";
+                            "set default": "set default";
+                        }>>;
+                        onUpdate: z.ZodOptional<z.ZodEnum<{
+                            cascade: "cascade";
+                            restrict: "restrict";
+                            "no action": "no action";
+                            "set null": "set null";
+                            "set default": "set default";
+                        }>>;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                    policies: z.ZodObject<{
+                        read: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>;
+                    }, z.core.$strict>;
+                    query: z.ZodString;
+                    dependencies: z.ZodArray<z.ZodString>;
+                    resolved: z.ZodOptional<z.ZodObject<{
+                        sources: z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            kind: z.ZodEnum<{
+                                manual: "manual";
+                                prefetch: "prefetch";
+                                etl: "etl";
+                            }>;
+                            table: z.ZodString;
+                            columns: z.ZodArray<z.ZodString>;
+                            updatedAt: z.ZodOptional<z.ZodString>;
+                            key: z.ZodOptional<z.ZodString>;
+                            fetch: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                                shape: z.ZodLiteral<"single">;
+                            }, z.core.$strict>, z.ZodObject<{
+                                shape: z.ZodLiteral<"batch">;
+                                maxKeys: z.ZodNumber;
+                            }, z.core.$strict>]>>;
+                            function: z.ZodOptional<z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    managed: "managed";
+                                    native: "native";
+                                }>;
+                                id: z.ZodString;
+                            }, z.core.$strict>>;
+                            prefetchDefaults: z.ZodOptional<z.ZodObject<{
+                                maxStalenessMs: z.ZodNumber;
+                                timeoutMs: z.ZodNumber;
+                                onError: z.ZodEnum<{
+                                    fallback: "fallback";
+                                    fail: "fail";
+                                }>;
+                            }, z.core.$strict>>;
+                            writeback: z.ZodOptional<z.ZodObject<{
+                                columns: z.ZodArray<z.ZodString>;
+                                defaultMode: z.ZodEnum<{
+                                    sync: "sync";
+                                    async: "async";
+                                }>;
+                                timeoutMs: z.ZodNumber;
+                                clearManualOnConfirm: z.ZodBoolean;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>>;
+                        resolve: z.ZodArray<z.ZodObject<{
+                            column: z.ZodString;
+                            comparator: z.ZodEnum<{
+                                custom: "custom";
+                                latest: "latest";
+                                highest: "highest";
+                                lowest: "lowest";
+                                priority: "priority";
+                                nonNullFirst: "nonNullFirst";
+                            }>;
+                            candidates: z.ZodArray<z.ZodString>;
+                            orderBy: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>;
+                        deletedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        materialized: z.ZodOptional<z.ZodObject<{
+                            table: z.ZodString;
+                            compute: z.ZodString;
+                        }, z.core.$strict>>;
+                        policies: z.ZodDefault<z.ZodObject<{
+                            write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                                default: z.ZodString;
+                                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                    when: z.ZodString;
+                                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                    policy: z.ZodOptional<z.ZodString>;
+                                }, z.core.$strip>>>;
+                            }, z.core.$strip>]>>;
+                            insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                                default: z.ZodString;
+                                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                    when: z.ZodString;
+                                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                    policy: z.ZodOptional<z.ZodString>;
+                                }, z.core.$strip>>>;
+                            }, z.core.$strip>]>>;
+                            update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                                default: z.ZodString;
+                                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                    when: z.ZodString;
+                                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                    policy: z.ZodOptional<z.ZodString>;
+                                }, z.core.$strip>>>;
+                            }, z.core.$strip>]>>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    internal: z.ZodOptional<z.ZodLiteral<true>>;
+                }, z.core.$strip>>>;
+                exports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    read: z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                        capability: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        role: z.ZodString;
+                    }, z.core.$strict>]>;
+                    write: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                        capability: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        role: z.ZodString;
+                    }, z.core.$strict>]>>;
+                }, z.core.$strict>>>;
+                capabilities: z.ZodDefault<z.ZodObject<{
+                    roles: z.ZodOptional<z.ZodUnknown>;
+                    uses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         documents: z.ZodArray<z.ZodObject<{
             path: z.ZodString;
@@ -1270,4 +1796,55 @@ declare function parseCanonicalDefinition(value: unknown): NamespaceDefinition;
 
 declare const parsedPredicateSchema: z.ZodPipe<z.ZodString, z.ZodTransform<ParsedPredicate, string>>;
 
-export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, type ActionDefinition, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CLAIMS_SETTING, CLAIM_KEY_PATTERN, COLUMN_IDENTIFIER_PATTERN, COLUMN_TYPES, COMPARE_OPS, CONSUMER_ROLE_SUFFIX, CanonicalDefinition, type ColumnDefault, type ColumnDefinition, type ColumnType, type CommittedChainEntry, type CommittedMigration, type CompareOp, type CompilePredIrToSqlOptions, type CompiledStatement, DEFINITION_FILE_EXTENSIONS, type DefinitionFile, type DefinitionSource, type DestructiveStatement, type DiffOptions, type DrizzleEntities, HASH_DOMAIN, IDENTIFIER_PATTERN, type IndexDefinition, type JournalEntry, type LinkDefinition, type LoadedNamespace, MAX_DEFINITION_FILE_BYTES, MAX_GENERATED_SDL_BYTES, MAX_IDENTIFIER_LENGTH, MIGRATIONS_DIRNAME, type MigrationJournal, type MigrationWorkspace, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, type NamespaceCapabilities, type NamespaceConfig, type NamespaceDefinition, type NamespaceSnapshot, ORM_DATA_TOKEN_HEADER, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, ORM_REGISTRATION_MAX_BYTES, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, type Operand, OrmDefinitionError, type OrmMigrationExport, type ParsedPredicate, type PlannedMigration, PredIr, type Predicate, type PredicateColumnTypes, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, type RebaseEntry, type RebaseEntryInput, type RebaseNoopOptions, STATEMENT_KINDS, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, type StatementKind, type SyncedBacking, type SyncedColumnType, type SyncedPredicateColumnTypes, type TableFile, type ValidatesEntry, type WrittenMigration, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, applyMigrationHints, applyMigrationHintsV2, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalizeDefinition, capabilityExpression, castParts, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, computeDefinitionHash, consumerRoleName, convertV1DefinitionToCanonical, createOrmMigrationExport, declaredCapabilityKeys, diffCommand, diffStatements, emptyJournal, emptySnapshot, extractNamedParams, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, identifierSchema, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, migrationName, namespaceConfigSchema, namespaceSchema, normalizeSnapshot, ormMigrationExportSchema, ormSchemaName, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planMigration, planMigrationV2, 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 };
+/** How a re-run treats a source key that is already in the ORM table. */
+declare const IMPORT_CONFLICT_MODES: readonly ["error", "skip", "update"];
+type ImportConflictMode = (typeof IMPORT_CONFLICT_MODES)[number];
+/**
+ * Copy one Lakebase/Postgres relation into an owned ORM table.
+ * The relation is where a warehouse table already lands after sync; this
+ * spec never accepts SQL text.
+ */
+declare const importSpecSchema: z.ZodObject<{
+    table: z.ZodString;
+    from: z.ZodString;
+    columns: z.ZodArray<z.ZodObject<{
+        target: z.ZodString;
+        source: z.ZodString;
+        nullDefault: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>>;
+    onConflict: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        update: "update";
+        skip: "skip";
+    }>>;
+    batchSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+type ImportSpec = z.infer<typeof importSpecSchema>;
+type ImportPlan = {
+    readonly probeSql: string;
+    readonly script: string;
+    readonly batchSize: number;
+    readonly onConflict: ImportConflictMode;
+    readonly warnings: readonly string[];
+};
+type ImportPlanResult = {
+    ok: true;
+    plan: ImportPlan;
+} | {
+    ok: false;
+    errors: readonly string[];
+};
+
+/**
+ * Plan a set-based copy from an existing Postgres relation into an owned ORM
+ * table. The relation is the Lakebase landing of a warehouse table. The plan
+ * is SQL text: identifiers are allowlisted, constants are typed literals, and
+ * no caller SQL is interpolated.
+ */
+declare function planTableImport({ definition, spec, after, }: {
+    definition: unknown;
+    spec: unknown;
+    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, type ValidatesEntry, type WrittenMigration, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, applyMigrationHints, applyMigrationHintsV2, 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 };