@sequenceholdings/orm 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -1,61 +1,15 @@
+export { AuthoringContext, AuthoringRegistration, COLUMN_BRAND, COLUMN_DEFAULT_FNS, ColumnBuilder, ColumnDefaultFn, ColumnDefaultLiteral, ColumnTypeSpec, CowMutationInput, DrizzleRelation, ENUM_BRAND, EnumRef, 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';
+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';
+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, INPUT_REF_KINDS, IR_VERSION, InputRefKind, IrVersionError, LimitIr, OrderIr, RootIr, SelectionIr, TableMetaIr, ValueIr, VariableDefaultIr, VariableIr, compiledArtifactSchema, compiledOperationSchema, indexByHash, limitIrSchema, normalizeIr, orderIrSchema, predIrSchema, rootIrSchema, selectionIrSchema, tableMetaIrSchema, valueIrSchema, variableDefaultIrSchema, variableIrSchema } from './ir.js';
 import { generateDrizzleJson } from 'drizzle-kit/api';
 import { PgTableWithColumns } from 'drizzle-orm/pg-core';
-
-/**
- * Custom Roles & Capabilities manifest grammar — the `capabilities.roles`
- * block and the `capabilities.uses` pin set. This is a VERBATIM mirror of the
- * platform's canonical grammar so an ORM namespace declares roles/capabilities
- * the exact same way an artifact or managed function does; apply feeds it to
- * the shared `reconcileHostRegistryOnActivation` reconciler untouched.
- *
- * Canonical sources — keep the grammar in sync by hand (schema shape, key
- * regexes, limits, and superRefine rules). The behavioral guards in
- * definitions.test.ts exercise this copy (inherit cycle, unknown grant,
- * pin-names-role, key collision) so a drifted rule fails there:
- *   atlas/src/server/services/custom-roles/manifest-block.ts        (server)
- *   shared/services/artifact-studio/src/manifest-custom-roles.ts    (CLI)
- */
-
-/**
- * Manifest-declared custom roles & capabilities. Roles and capabilities are
- * both `custom_role` FGA objects; deploy reconciliation turns this block into
- * the structural waterfall edges (role→capability / senior→junior `assignee`
- * userset tuples) — nothing else. The host floor is enforced app-layer at the
- * resolution points, never in the model. Runtime grants (user/group/org →
- * role) are NEVER declared here — they are written through host-admin-gated
- * endpoints.
- */
-declare const customRolesBlockSchema: z.ZodObject<{
-    definitions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-        description: z.ZodOptional<z.ZodString>;
-        default: z.ZodDefault<z.ZodBoolean>;
-        inherits: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        grants: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>;
-    capabilities: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-type CustomRolesBlock = z.infer<typeof customRolesBlockSchema>;
-/** True when the block declares at least one role or capability. */
-declare function customRolesDeclared(block: CustomRolesBlock | null | undefined): boolean;
-declare const capabilityPinsSchema: z.ZodDefault<z.ZodArray<z.ZodString>>;
-interface ParsedCapabilityPin {
-    scope: 'org' | 'host';
-    key: string;
-}
-/** Split a pin into its scope and key. Assumes the pin grammar validated. */
-declare function parseCapabilityPin(pin: string): ParsedCapabilityPin;
-/**
- * Cross-field pin validation (the `uses` array and the roles block are
- * siblings under `capabilities`). Purely structural — registry existence
- * checks are server-side, at activation, where atomicity lives.
- */
-declare function validateCapabilityPins({ uses, roles, }: {
-    uses: readonly string[];
-    roles: CustomRolesBlock | null | undefined;
-}): string[];
+import 'drizzle-orm';
+import 'drizzle-orm/query-builders/query-builder';
 
 /**
  * The reserved `namespace.yaml` — namespace-level settings beside the table
@@ -148,8 +102,8 @@ declare const actionSchema: z.ZodObject<{
     }>>>;
     audit: z.ZodOptional<z.ZodObject<{
         action: z.ZodEnum<{
-            create: "create";
             update: "update";
+            create: "create";
             delete: "delete";
         }>;
         resource: z.ZodOptional<z.ZodString>;
@@ -295,6 +249,8 @@ declare const tableFileSchema: z.ZodObject<{
     policies: z.ZodOptional<z.ZodObject<{
         read: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<ParsedPredicate, string>>>;
         write: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<ParsedPredicate, string>>>;
+        insert: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<ParsedPredicate, string>>>;
+        update: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<ParsedPredicate, string>>>;
     }, z.core.$strict>>;
     actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
@@ -331,8 +287,8 @@ declare const tableFileSchema: z.ZodObject<{
         }>>>;
         audit: z.ZodOptional<z.ZodObject<{
             action: z.ZodEnum<{
-                create: "create";
                 update: "update";
+                create: "create";
                 delete: "delete";
             }>;
             resource: z.ZodOptional<z.ZodString>;
@@ -396,6 +352,24 @@ declare function compileActionStatements(action: ActionDefinition, renderParam?:
 /** Compiled `requires` gate — a SQL boolean over the transaction claims, or null when unguarded. */
 declare function compileActionRequires(action: ActionDefinition): string | null;
 
+/** Canonical column types can be enums — v1 `PredicateColumnTypes` cannot carry them. */
+type SyncedColumnType = ColumnType | {
+    readonly enum: string;
+};
+type SyncedPredicateColumnTypes = Readonly<Record<string, SyncedColumnType>>;
+interface CompilePredIrToSqlOptions {
+    /** Column name → declared type, for claim casts in comparisons. */
+    readonly columnTypes?: SyncedPredicateColumnTypes;
+    /** Logical column name → physical column name for the synced backing. */
+    readonly columnNames?: Readonly<Record<string, string>>;
+}
+/**
+ * PredIr → a static SQL boolean for synced-view WHERE clauses. Capability and
+ * role leaves stay as runtime claim checks (mirroring table RLS), unlike the
+ * data-plane executor which pre-resolves them per caller.
+ */
+declare function compilePredIrToSql(pred: PredIr, options?: CompilePredIrToSqlOptions): string;
+
 declare const COMPARE_OPS: readonly ["=", "!=", "<", "<=", ">", ">="];
 type CompareOp = (typeof COMPARE_OPS)[number];
 type Operand = {
@@ -444,11 +418,15 @@ declare function compilePredicate(predicate: Predicate, columnTypes?: PredicateC
 declare const CLAIMS_SETTING = "request.jwt.claims";
 /** Claims JSON key holding the caller's granted capability pins (a string array). */
 declare const CAPABILITIES_CLAIM_KEY = "capabilities";
+/** Claims JSON key holding the caller's granted custom roles (a string array). */
+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;
+/** 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;
@@ -543,6 +521,7 @@ declare function applyMigrationHints(previous: NamespaceSnapshot, definition: Na
  * pending statement and lets a non-converged schema pass.
  */
 declare function isOwnedStatement(statement: string): boolean;
+declare function isOwnedStatementV2(statement: string): boolean;
 /**
  * The kit-owned statements a live database would still need to match the
  * definition — drizzle-kit's `pushSchema` introspection diffed against the
@@ -555,6 +534,12 @@ declare function pendingKitStatements({ definition, db, }: {
     /** A drizzle PgDatabase over the target — typed loose because pushSchema's own parameter is `PgDatabase<any>`. */
     db: unknown;
 }): Promise<string[]>;
+/** V2 convergence includes managed regular views in drizzle-kit's verdict. */
+declare function pendingKitStatementsV2({ canonical, db, }: {
+    canonical: CanonicalDefinition;
+    /** A drizzle PgDatabase over the target — typed loose because pushSchema's own parameter is `PgDatabase<any>`. */
+    db: unknown;
+}): Promise<string[]>;
 
 interface DrizzleEntities {
     /** The in-memory schema bag drizzle-kit snapshots (`generateDrizzleJson(imports)`). */
@@ -618,10 +603,68 @@ declare function actionPrepareChecks(definition: NamespaceDefinition): string[];
  * write-capable callers SELECT rows the read policy hides.
  */
 declare function securityStatements(definition: NamespaceDefinition): string[];
+declare const syncedTables: (definition: NamespaceDefinition) => TableFile[];
+/**
+ * A resolved synced-table backing: the physical Lakebase relation name
+ * (captured at provision, never derived) plus optional projection column
+ * types for claim-cast compilation.
+ */
+interface SyncedBacking {
+    readonly table: string;
+    /** Physical Lakebase relation (e.g. `synced_loans` or `df_retail_customers`). */
+    readonly physicalRelation: string;
+    /** Column name → ORM column type, for claim casts in the view's WHERE. */
+    readonly columnTypes?: PredicateColumnTypes;
+}
+/**
+ * Emit CREATE OR REPLACE VIEW + SELECT-only grants for synced tables that have
+ * a registered backing. Synced tables cannot use table-level RLS (they may be
+ * foreign tables), so claims filtering compiles into the view's WHERE clause.
+ *
+ * Each view lives in `orm_<ns>` alongside regular tables, named identically to
+ * the synced table definition so read routing is transparent.
+ */
+/**
+ * Atlas reassigns every relation in `orm_<ns>` to this role after apply.
+ * Synced views resolve backing access as their owner, so the emitter must
+ * grant this role narrow SELECT on each physical relation before CREATE VIEW.
+ */
+declare const SYNCED_VIEW_EXECUTION_OWNER_ROLE = "orm_exec";
+declare function syncedViewStatements({ definition, backings, readPolicyIrByTable, columnNamesByTable, columnTypesByTable, executionOwnerRole, }: {
+    definition: NamespaceDefinition;
+    backings: readonly SyncedBacking[];
+    /** v2 compiled read policies (preserves capability/role variants). */
+    readPolicyIrByTable?: ReadonlyMap<string, PredIr>;
+    /** Logical column name → physical backing column name per synced table. */
+    columnNamesByTable?: ReadonlyMap<string, Readonly<Record<string, string>>>;
+    /**
+     * Canonical declared types per synced table (keyed by logical AND physical
+     * name). Carries what the TableFile adapter cannot — enum types — so IN/NIN
+     * policies never silently downgrade an enum comparison to text[]-vs-enum.
+     */
+    columnTypesByTable?: ReadonlyMap<string, SyncedPredicateColumnTypes>;
+    /** Role that will own the view after ensureExecutionOwner (default orm_exec). */
+    executionOwnerRole?: string;
+}): string[];
+/**
+ * Drop synced views — idempotent cleanup for apply retries and removal.
+ */
+declare function syncedViewDropStatements({ schemaName, tables, }: {
+    schemaName: string;
+    tables: readonly string[];
+}): string[];
+/**
+ * Revoke orm_exec backing privileges for physical relations that are no longer
+ * active for this namespace (removed / renamed / rebound away).
+ */
+declare function syncedBackingRevokeStatements({ backings, executionOwnerRole, }: {
+    backings: readonly SyncedBacking[];
+    executionOwnerRole?: string;
+}): string[];
 
 declare const sqlTypeName: (type: ColumnType) => string;
 
-declare const STATEMENT_KINDS: readonly ["hint", "ddl", "security", "function"];
+declare const STATEMENT_KINDS: readonly ["hint", "ddl", "security", "function", "synced_view"];
 type StatementKind = (typeof STATEMENT_KINDS)[number];
 interface CompiledStatement {
     readonly kind: StatementKind;
@@ -649,6 +692,64 @@ declare function planMigration({ definition, previousSnapshot, }: {
 /** Full-create plan (empty previous snapshot) — what `plan` prints and first apply runs. */
 declare const compileNamespace: (definition: NamespaceDefinition) => Promise<PlannedMigration>;
 
+/**
+ * Canonical v2 → the in-memory schema bag drizzle-kit snapshots plus typed
+ * table handles — the same `DrizzleEntities` shape engine/snapshot.ts consumes.
+ */
+declare function buildDrizzleEntitiesV2(definition: CanonicalDefinition): DrizzleEntities;
+declare function rewriteSyncedSourceRelationsInViewQuery({ query, canonical, schemaName, dependencies, }: {
+    query: string;
+    canonical: CanonicalDefinition;
+    schemaName: string;
+    /** The view's declared logical dependencies — disambiguates shared sources. */
+    dependencies?: readonly string[];
+}): string;
+/** drizzle-kit snapshot for a canonical definition — the v2 twin of engine/snapshot.ts generateSnapshot. */
+declare function generateSnapshotV2(definition: CanonicalDefinition, previousId?: string): NamespaceSnapshot;
+/**
+ * Renames and casts are declared in the canonical definition, never inferred:
+ * 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).
+ *
+ * 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
+ * table renames or enum-typed cast targets.
+ */
+declare function applyMigrationHintsV2(previous: NamespaceSnapshot, definition: CanonicalDefinition): MigrationHints;
+/**
+ * Desired canonical definition + the previously applied snapshot → ordered
+ * statements. The v2 twin of engine/index.ts planMigration, reusing its
+ * exported internals (normalizeSnapshot/emptySnapshot/diffStatements — the
+ * assertUnambiguousDiff backstop rides along inside diffStatements).
+ *
+ * Deliberately absent relative to v1: policy drops, securityStatements, and
+ * 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.
+ */
+declare function planMigrationV2({ canonical, previousSnapshot, }: {
+    canonical: CanonicalDefinition;
+    previousSnapshot?: NamespaceSnapshot;
+}): Promise<PlannedMigration>;
+/**
+ * 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
+ * the same transaction so a stale alias/type or an incomplete dependency
+ * declaration can never be persisted as a successful schema version.
+ */
+/**
+ * Assert live view columns/types/dependencies match the canonical contract.
+ * Used by planMigrationV2 and by CASCADE recovery recreates (same transaction).
+ */
+declare function validateViewCatalogStatement({ canonical, view, schema, }: {
+    canonical: CanonicalDefinition;
+    view: NonNullable<CanonicalDefinition['views']>[number];
+    schema: string;
+}): string;
+
 declare class OrmDefinitionError extends Error {
     readonly file?: string | undefined;
     readonly name = "OrmDefinitionError";
@@ -818,6 +919,82 @@ declare function writeMigration({ dir, workspace, plan, contentHash, destructive
     destructive: boolean;
 }): Promise<WrittenMigration>;
 
+/**
+ * v1 YAML `NamespaceDefinition` → canonical v2 (`orm migrate-from-yaml`).
+ * Lossless where the v2 contract can express it, loud where it can't:
+ *
+ *  - columns keep declaration order (order is meaningful for DDL); the v1
+ *    `default` splits into literal `default` vs allowlisted `defaultFn`
+ *    exactly along the isFunctionDefault line the v1 engine used;
+ *  - the single v1 `primary_key: true` column becomes `primaryKey: [name]`;
+ *  - policy expressions carry over as their verbatim DSL source strings
+ *    (re-parsed by the v2 predicate compiler, never the parsed v1 AST);
+ *  - v1 actions are DROPPED, loudly: v2 has no action surface — writes are
+ *    persisted mutations — and the v1→v2 apply sweep removes the `action_*`
+ *    functions anyway. The emitter leaves a TODO listing each dropped action
+ *    so it gets re-authored as a mutation (or a CoW `overrideRowMutation`);
+ *  - the capabilities block passes through untouched (verbatim custom-roles
+ *    grammar in both formats);
+ *  - qualified (cross-namespace) link targets have no v2 representation —
+ *    links are namespace-local in v2 (plan §5) — so they fail the conversion
+ *    rather than silently dropping.
+ *
+ * The result re-validates through canonicalDefinitionSchema and normalizes,
+ * so hashing and server-side re-validation see exactly what an authored v2
+ * definition would produce.
+ */
+declare function convertV1DefinitionToCanonical(definition: NamespaceDefinition): CanonicalDefinition;
+
+/** Statement kinds that disqualify a plan from being a rebase no-op. */
+interface RebaseNoopOptions {
+    /**
+     * v1 planned a drop-and-recreate of the RLS policies on every migration, so
+     * a plan produced by the V1 PIPELINE against an unchanged schema still
+     * carries `security` statements. v2 plans never emit them. Default false:
+     * a rebase verified through planMigrationV2 must be empty outright.
+     */
+    readonly allowSecurityReemission?: boolean;
+}
+/** The statements that stop a plan from qualifying as a rebase no-op. */
+declare function rebaseViolations(statements: readonly CompiledStatement[], options?: RebaseNoopOptions): CompiledStatement[];
+/**
+ * True when the plan changes nothing: no DDL, no hint (rename/cast) ALTERs,
+ * no action functions — and, unless explicitly allowed, no security
+ * re-emission either. Pure predicate over the plan's statements.
+ */
+declare const verifyRebaseIsNoop: (plan: Pick<PlannedMigration, "statements">, options?: RebaseNoopOptions) => boolean;
+interface RebaseEntryInput {
+    readonly namespace: string;
+    /** Content hash at the committed journal tip (the v1 hash being rebased from). */
+    readonly previousHash: string;
+    /** Content hash of the converted canonical v2 definition. */
+    readonly newHash: string;
+    /** Journal tip ordinal + 1. A rebase always sits on an existing tip. */
+    readonly ordinal: number;
+    /**
+     * The verified no-op plan's snapshot. Structurally identical to the tip
+     * snapshot but re-chained (fresh `id`, `prevId` = tip snapshot's id) so the
+     * `--check` snapshot-chain walk stays unbroken through the rebase.
+     */
+    readonly snapshot: NamespaceSnapshot;
+}
+interface RebaseEntry {
+    readonly name: string;
+    /** Journal entry matching workspace.ts's journalEntrySchema exactly. */
+    readonly entry: JournalEntry;
+    /** `migrations/<name>.sql` contents — header only, zero statements. */
+    readonly sql: string;
+    /** `migrations/meta/NNNN.snapshot.json` contents (writeMigration's serialization). */
+    readonly snapshotText: string;
+}
+/**
+ * Build the no-op journal entry (+ the exact file contents its checksums
+ * commit to) recording a v1 → v2 content-hash rebase. Everything is
+ * deterministic from the inputs, so `--check`-style gates can regenerate and
+ * byte-compare it just like ordinary migrations.
+ */
+declare function buildRebaseJournalEntry({ namespace, previousHash, newHash, ordinal, snapshot }: RebaseEntryInput): RebaseEntry;
+
 declare function parsePredicate(source: string): ParsedPredicate;
 
 declare const identifierSchema: z.ZodString;
@@ -836,4 +1013,4 @@ 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_TYPES, COMPARE_OPS, CONSUMER_ROLE_SUFFIX, type ColumnDefault, type ColumnDefinition, type ColumnType, type CommittedChainEntry, type CommittedMigration, type CompareOp, type CompiledStatement, type CustomRolesBlock, 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_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_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, type Operand, OrmDefinitionError, type ParsedPredicate, type PlannedMigration, type Predicate, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, STATEMENT_KINDS, SYNCED_SOURCE_PATTERN, type StatementKind, type TableFile, type ValidatesEntry, type WrittenMigration, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, applyMigrationHints, buildActionParamsSchema, buildDrizzleEntities, buildNamespaceDefinition, canonicalizeDefinition, capabilityExpression, capabilityPinsSchema, castParts, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredicate, computeDefinitionHash, consumerRoleName, customRolesBlockSchema, customRolesDeclared, declaredCapabilityKeys, diffCommand, diffStatements, emptyJournal, emptySnapshot, extractNamedParams, generateNamespaceTypes, generateSnapshot, identifierSchema, isFunctionDefault, isOwnedStatement, isQualifiedReference, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, migrationName, namespaceConfigSchema, namespaceSchema, normalizeSnapshot, ormSchemaName, parseCanonicalDefinition, parseCapabilityPin, parseDefinitionSources, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, planMigration, predicateOperands, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readSnapshot, referencedCapabilities, referencedColumns, renderMigrationSql, securityStatements, sqlTypeName, stableJson, tableFileSchema, tableReferenceSchema, typesInterfaceName, validateCapabilityPins, walkPredicate, writeMigration };
+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_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_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_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, type Operand, OrmDefinitionError, 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, declaredCapabilityKeys, diffCommand, diffStatements, emptyJournal, emptySnapshot, extractNamedParams, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, identifierSchema, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, migrationName, namespaceConfigSchema, namespaceSchema, normalizeSnapshot, ormSchemaName, parseCanonicalDefinition, parseDefinitionSources, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planMigration, planMigrationV2, predicateOperands, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, rewriteSyncedSourceRelationsInViewQuery, roleExpression, securityStatements, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedTables, syncedViewDropStatements, syncedViewStatements, tableFileSchema, tableReferenceSchema, typesInterfaceName, validateViewCatalogStatement, verifyRebaseIsNoop, walkPredicate, writeMigration };