@prisma-next/contract 0.13.0-dev.3 → 0.13.0-dev.31

package/dist/apply-specifier-default-control-policy.d.mts

@@ -1,4 +1,4 @@
-import { L as ControlPolicy, t as Contract } from "./contract-types-CBbD-VV1.mjs";
+import { a as ControlPolicy, t as Contract } from "./contract-types-ci3TUzpo.mjs";
 
 //#region src/apply-specifier-default-control-policy.d.ts
 declare function applySpecifierDefaultControlPolicy(contract: Contract, specifierDefault: ControlPolicy | undefined): Contract;

package/dist/{canonicalization-ChdV0ueh.d.mts → canonicalization-C2ecs9k1.d.mts}

@@ -1,4 +1,4 @@
-import { t as Contract } from "./contract-types-CBbD-VV1.mjs";
+import { t as Contract } from "./contract-types-ci3TUzpo.mjs";
 import { JsonObject } from "@prisma-next/utils/json";
 
 //#region src/canonicalization.d.ts
@@ -66,4 +66,4 @@ declare function canonicalizeContractToObject(contract: Contract, options: Canon
 declare function canonicalizeContract(contract: Contract, options: CanonicalizeContractOptions): string;
 //#endregion
 export { canonicalizeContract as a, StorageSort as i, PreserveEmptyPredicate as n, canonicalizeContractToObject as o, SerializeContract as r, CanonicalizeContractOptions as t };
-//# sourceMappingURL=canonicalization-ChdV0ueh.d.mts.map
+//# sourceMappingURL=canonicalization-C2ecs9k1.d.mts.map

package/dist/{canonicalization-ChdV0ueh.d.mts.map → canonicalization-C2ecs9k1.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"canonicalization-ChdV0ueh.d.mts","names":[],"sources":["../src/canonicalization.ts"],"mappings":";;;;;;AAcA;;;;;;KAAY,iBAAA,IAAqB,QAAA,EAAU,QAAA,KAAa,UAAU;;AAAA;AAUlE;;;;AAA6D;AAS7D;KATY,sBAAA,IAA0B,IAAuB;;;AASlB;AAqL3C;;;;KArLY,WAAA,IAAe,OAAgB;AAAA,UAqL1B,2BAAA;EAAA,SACN,aAAA;EAAA;;;;;;;;AA0ByB;AAQpC;EAlCW,SAWA,iBAAA,EAAmB,iBAAA;;;;;;;WAOnB,mBAAA,GAAsB,sBAAA;EAiB/B;;;;;AAEO;AA2BT;EA7BE,SATS,WAAA,GAAc,WAAA;AAAA;;;;;;iBAQT,4BAAA,CACd,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,2BAAA,GACR,MAAA;AAAA,iBA2Ba,oBAAA,CACd,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,2BAA2B"}
+{"version":3,"file":"canonicalization-C2ecs9k1.d.mts","names":[],"sources":["../src/canonicalization.ts"],"mappings":";;;;;;AAcA;;;;;;KAAY,iBAAA,IAAqB,QAAA,EAAU,QAAA,KAAa,UAAU;;AAAA;AAUlE;;;;AAA6D;AAS7D;KATY,sBAAA,IAA0B,IAAuB;;;AASlB;AAqL3C;;;;KArLY,WAAA,IAAe,OAAgB;AAAA,UAqL1B,2BAAA;EAAA,SACN,aAAA;EAAA;;;;;;;;AA0ByB;AAQpC;EAlCW,SAWA,iBAAA,EAAmB,iBAAA;;;;;;;WAOnB,mBAAA,GAAsB,sBAAA;EAiB/B;;;;;AAEO;AA2BT;EA7BE,SATS,WAAA,GAAc,WAAA;AAAA;;;;;;iBAQT,4BAAA,CACd,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,2BAAA,GACR,MAAA;AAAA,iBA2Ba,oBAAA,CACd,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,2BAA2B"}

package/dist/contract-types-ci3TUzpo.d.mts

@@ -0,0 +1,82 @@
+import { F as ExecutionMutationDefault, J as StorageBase, K as ProfileHashBase, P as ExecutionHashBase, _ as ContractValueObject, d as ContractModelBase, it as CrossReference, t as ApplicationDomain } from "./domain-envelope-Czz8UMhU.mjs";
+
+//#region src/control-policy.d.ts
+/**
+ * Governance posture for a storage-plane node or for the contract as a whole.
+ *
+ * - `managed`  — Prisma Next owns the full lifecycle (DDL, migrations, verification).
+ * - `tolerated` — node was found in the database but is not schema-managed; Prisma Next
+ *   leaves it untouched while tracking its existence.
+ * - `external` — node is owned by an external system; Prisma Next never emits DDL for it.
+ * - `observed` — read-only access; Prisma Next does not write to or migrate the node.
+ */
+type ControlPolicy = 'managed' | 'tolerated' | 'external' | 'observed';
+/**
+ * Resolves the effective control policy for a storage-plane node.
+ *
+ * Precedence: node-level value → contract default → `'managed'`.
+ *
+ * Both parameters are optional raw values so this function stays node-type-agnostic
+ * and can be called by any consumer (verifier, planner, etc.) without importing IR classes.
+ */
+declare function effectiveControlPolicy(nodeControl: ControlPolicy | undefined, defaultControlPolicy: ControlPolicy | undefined): ControlPolicy;
+//#endregion
+//#region src/contract-types.d.ts
+/**
+ * Execution section for the unified contract (ADR 182).
+ *
+ * Unlike the legacy {@link import('./types').ExecutionSection}, this type
+ * requires `executionHash` — when an execution section is present, its
+ * hash must be too (consistent with `StorageBase.storageHash`).
+ *
+ * @template THash  Literal hash string type for type-safe hash tracking.
+ */
+type ContractExecutionSection<THash extends string = string> = {
+  readonly executionHash: ExecutionHashBase<THash>;
+  readonly mutations: {
+    readonly defaults: ReadonlyArray<ExecutionMutationDefault>;
+  };
+};
+/**
+ * Unified contract representation (ADR 182).
+ *
+ * A `Contract` is the canonical in-memory representation of a data contract.
+ * It is model-first (domain models carry their own storage bridge) and
+ * family-parameterized (SQL, Mongo, etc. specialize via `TStorage` and model
+ * storage generics on `ContractModel`).
+ *
+ * JSON persistence fields (`schemaVersion`, `sources`) are not represented
+ * here — they are handled at the serialization boundary.
+ *
+ * @template TStorage  Family-specific storage block (extends {@link StorageBase}).
+ * @template TModels   Record of model name → {@link ContractModel} with
+ *                     family-specific model storage.
+ */
+interface Contract<TStorage extends StorageBase = StorageBase, TModels extends Record<string, ContractModelBase> = Record<string, ContractModelBase>> {
+  readonly target: string;
+  readonly targetFamily: string;
+  readonly roots: Record<string, CrossReference>;
+  /**
+   * Application plane (ADR 221): `domain.namespaces.<nsId>.{ models, valueObjects }`.
+   * `TModels` types the union of model entries across namespaces for family DSL inference.
+   */
+  readonly domain: ApplicationDomain<TModels>;
+  readonly storage: TStorage;
+  readonly capabilities: Record<string, Record<string, boolean>>;
+  readonly extensionPacks: Record<string, unknown>;
+  readonly execution?: ContractExecutionSection;
+  readonly profileHash: ProfileHashBase<string>;
+  readonly meta: Record<string, unknown>;
+  readonly defaultControlPolicy?: ControlPolicy;
+}
+/** Model definitions union carried on a {@link Contract}'s `TModels` type parameter. */
+type ContractModelDefinitions<TContract extends Contract> = TContract extends Contract<StorageBase, infer TModels> ? TModels : never;
+type ExactlyOneNamespace<T extends Record<string, unknown>> = keyof T extends infer Only extends keyof T ? [keyof T] extends [Only] ? Only : never : never;
+type NamespaceValueObjectsOf<TNamespace> = TNamespace extends {
+  readonly valueObjects?: infer VO;
+} ? VO extends Record<string, ContractValueObject> ? VO : Record<never, never> : Record<never, never>;
+/** Value-object map when the contract declares exactly one domain namespace. */
+type ContractValueObjectDefinitions<TContract extends Contract> = NamespaceValueObjectsOf<TContract['domain']['namespaces'][ExactlyOneNamespace<TContract['domain']['namespaces']>]> extends infer Projected ? Projected extends Record<string, ContractValueObject> ? Projected : Record<never, never> : Record<never, never>;
+//#endregion
+export { ControlPolicy as a, ContractValueObjectDefinitions as i, ContractExecutionSection as n, effectiveControlPolicy as o, ContractModelDefinitions as r, Contract as t };
+//# sourceMappingURL=contract-types-ci3TUzpo.d.mts.map

package/dist/contract-types-ci3TUzpo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-types-ci3TUzpo.d.mts","names":[],"sources":["../src/control-policy.ts","../src/contract-types.ts"],"mappings":";;;;;;AASA;;;;AAAyB;AAUzB;KAVY,aAAA;;;;;;;;;iBAUI,sBAAA,CACd,WAAA,EAAa,aAAA,cACb,oBAAA,EAAsB,aAAA,eACrB,aAAA;;;;;AAbsB;AAUzB;;;;;;KCCY,wBAAA;EAAA,SACD,aAAA,EAAe,iBAAA,CAAkB,KAAA;EAAA,SACjC,SAAA;IAAA,SACE,QAAA,EAAU,aAAA,CAAc,wBAAA;EAAA;AAAA;;;ADDrB;;;;ACFhB;;;;;;;;;UAsBiB,QAAA,kBACE,WAAA,GAAc,WAAA,kBACf,MAAA,SAAe,iBAAA,IAAqB,MAAA,SAAe,iBAAA;EAAA,SAE1D,MAAA;EAAA,SACA,YAAA;EAAA,SACA,KAAA,EAAO,MAAA,SAAe,cAAA;EA1BtB;;;;EAAA,SA+BA,MAAA,EAAQ,iBAAA,CAAkB,OAAA;EAAA,SAC1B,OAAA,EAAS,QAAA;EAAA,SACT,YAAA,EAAc,MAAA,SAAe,MAAA;EAAA,SAC7B,cAAA,EAAgB,MAAA;EAAA,SAChB,SAAA,GAAY,wBAAA;EAAA,SACZ,WAAA,EAAa,eAAA;EAAA,SACb,IAAA,EAAM,MAAA;EAAA,SACN,oBAAA,GAAuB,aAAA;AAAA;;KAItB,wBAAA,mBAA2C,QAAA,IACrD,SAAA,SAAkB,QAAA,CAAS,WAAA,mBAA8B,OAAA;AAAA,KAEtD,mBAAA,WAA8B,MAAA,2BAAiC,CAAA,kCAC5D,CAAA,UACG,CAAA,WAAY,IAAA,IACjB,IAAA;AAAA,KAID,uBAAA,eAAsC,UAAA;EAAA,SAChC,YAAA;AAAA,IAEP,EAAA,SAAW,MAAA,SAAe,mBAAA,IACxB,EAAA,GACA,MAAA,iBACF,MAAA;;KAGQ,8BAAA,mBAAiD,QAAA,IAC3D,uBAAA,CACE,SAAA,yBAAkC,mBAAA,CAAoB,SAAA,sDAEpD,SAAA,SAAkB,MAAA,SAAe,mBAAA,IAC/B,SAAA,GACA,MAAA,iBACF,MAAA"}

package/dist/domain-envelope-Czz8UMhU.d.mts

@@ -0,0 +1,357 @@
+//#region src/namespace-id.d.ts
+type NamespaceId = string & {
+  readonly __brand: 'NamespaceId';
+};
+declare function asNamespaceId(value: string): NamespaceId;
+//#endregion
+//#region src/cross-reference.d.ts
+interface CrossReference {
+  readonly namespace: NamespaceId;
+  readonly model: string;
+  /**
+   * Contract-space identity for cross-space relations. When present, the
+   * referenced model lives in a different contract space. Absent for local
+   * (same-space) relations.
+   */
+  readonly space?: string;
+}
+declare const CrossReferenceSchema: import("arktype/internal/variants/object.ts").ObjectType<CrossReference, {}>;
+declare function crossRef(model: string, namespace?: string, space?: string): CrossReference;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Unique symbol used as the key for branding types.
+ */
+declare const $: unique symbol;
+/**
+ * A helper type to brand a given type with a unique identifier.
+ *
+ * @template TKey Text used as the brand key.
+ * @template TValue Optional value associated with the brand key. Defaults to `true`.
+ */
+type Brand<TKey extends string | number | symbol, TValue = true> = {
+  [$]: { [K in TKey]: TValue };
+};
+/**
+ * Base type for storage contract hashes.
+ * Emitted contract.d.ts files use this with the hash value as a type parameter:
+ * `type StorageHash = StorageHashBase<'sha256:abc123...'>`
+ */
+type StorageHashBase<THash extends string> = THash & Brand<'StorageHash'>;
+/**
+ * Base type for execution contract hashes.
+ * Emitted contract.d.ts files use this with the hash value as a type parameter:
+ * `type ExecutionHash = ExecutionHashBase<'sha256:def456...'>`
+ */
+type ExecutionHashBase<THash extends string> = THash & Brand<'ExecutionHash'>;
+declare function executionHash<const T extends string>(value: T): ExecutionHashBase<T>;
+declare function coreHash<const T extends string>(value: T): StorageHashBase<T>;
+/**
+ * Base type for profile contract hashes.
+ * Emitted contract.d.ts files use this with the hash value as a type parameter:
+ * `type ProfileHash = ProfileHashBase<'sha256:def456...'>`
+ */
+type ProfileHashBase<THash extends string> = THash & Brand<'ProfileHash'>;
+declare function profileHash<const T extends string>(value: T): ProfileHashBase<T>;
+/**
+ * One entity-kind slot in a namespace — a map of entity name to entry.
+ * Values are opaque at the foundation layer; family and target concretions
+ * refine them to typed IR classes.
+ */
+type StorageEntitySlot = Readonly<Record<string, unknown>>;
+/**
+ * Plain-data namespace entry in a storage block. Every hydrated contract
+ * carries at least `id` plus entity-kind slot maps under `entries`
+ * (`table`, `collection`, …). Foundation declares only this shape — no IR
+ * machinery.
+ */
+interface StorageNamespace {
+  readonly id: string;
+  readonly entries: Readonly<Record<string, StorageEntitySlot>>;
+}
+/**
+ * Base type for family-specific storage blocks.
+ * Family storage types (SqlStorage, MongoStorage, etc.) extend this to carry the
+ * storage hash alongside family-specific data (tables, collections, etc.).
+ *
+ * The `namespaces` map is carried by every hydrated storage block. Serialized
+ * envelope shape is target-owned; this types the in-memory contract after
+ * `deserializeContract`.
+ */
+interface StorageBase<THash extends string = string> {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly namespaces: Readonly<Record<string, StorageNamespace>>;
+}
+interface FieldType {
+  readonly type: string;
+  readonly nullable: boolean;
+  readonly items?: FieldType;
+  readonly properties?: Record<string, FieldType>;
+}
+type GeneratedValueSpec = {
+  readonly id: string;
+  readonly params?: Record<string, unknown>;
+};
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | {
+  readonly [key: string]: JsonValue;
+} | readonly JsonValue[];
+type ColumnDefaultLiteralValue = JsonValue;
+type ColumnDefaultLiteralInputValue = ColumnDefaultLiteralValue | Date;
+/**
+ * Runtime predicate for `ColumnDefaultLiteralInputValue`. Authoring layers
+ * resolve template values from caller-supplied args (typed `unknown` at the
+ * boundary) and need to validate before constructing a `ColumnDefault`.
+ * Accepts JSON primitives, plain arrays/objects of JSON values, and `Date`
+ * instances. Rejects functions, class instances (other than `Date`),
+ * `undefined`, `bigint`, `symbol`, and arrays/objects containing those.
+ */
+declare function isColumnDefaultLiteralInputValue(value: unknown): value is ColumnDefaultLiteralInputValue;
+type ColumnDefault = {
+  readonly kind: 'literal';
+  readonly value: ColumnDefaultLiteralInputValue;
+} | {
+  readonly kind: 'function';
+  readonly expression: string;
+};
+declare function isColumnDefault(value: unknown): value is ColumnDefault;
+type ExecutionMutationDefaultValue = {
+  readonly kind: 'generator';
+  readonly id: GeneratedValueSpec['id'];
+  readonly params?: Record<string, unknown>;
+};
+declare function isExecutionMutationDefaultValue(value: unknown): value is ExecutionMutationDefaultValue;
+type ExecutionMutationDefault = {
+  readonly ref: {
+    readonly table: string;
+    readonly column: string;
+  };
+  readonly onCreate?: ExecutionMutationDefaultValue;
+  readonly onUpdate?: ExecutionMutationDefaultValue;
+};
+/**
+ * `ExecutionMutationDefault` minus its `ref` — the per-field phases value
+ * authoring layers attach to a column before the column ref is known.
+ */
+type ExecutionMutationDefaultPhases = Omit<ExecutionMutationDefault, 'ref'>;
+type ExecutionSection<THash extends string = string> = {
+  readonly executionHash: ExecutionHashBase<THash>;
+  readonly mutations: {
+    readonly defaults: ReadonlyArray<ExecutionMutationDefault>;
+  };
+};
+interface Source {
+  readonly readOnly: boolean;
+  readonly projection: Record<string, FieldType>;
+  readonly origin?: Record<string, unknown>;
+  readonly capabilities?: Record<string, boolean>;
+}
+interface DocIndex {
+  readonly name: string;
+  readonly keys: Record<string, 'asc' | 'desc'>;
+  readonly unique?: boolean;
+  readonly where?: Expr;
+}
+type Expr = {
+  readonly kind: 'eq';
+  readonly path: ReadonlyArray<string>;
+  readonly value: unknown;
+} | {
+  readonly kind: 'exists';
+  readonly path: ReadonlyArray<string>;
+};
+interface DocCollection {
+  readonly name: string;
+  readonly id?: {
+    readonly strategy: 'auto' | 'client' | 'uuid' | 'objectId';
+  };
+  readonly fields: Record<string, FieldType>;
+  readonly indexes?: ReadonlyArray<DocIndex>;
+  readonly readOnly?: boolean;
+}
+interface PlanMeta {
+  readonly target: string;
+  readonly targetFamily?: string;
+  readonly storageHash: string;
+  readonly profileHash?: string;
+  readonly lane: string;
+  readonly annotations?: {
+    readonly [key: string]: unknown;
+  };
+}
+/**
+ * Contract marker record stored in the database.
+ * Represents the current contract identity for a database.
+ */
+interface ContractMarkerRecord {
+  readonly storageHash: string;
+  readonly profileHash: string;
+  readonly contractJson: unknown | null;
+  readonly canonicalVersion: number | null;
+  readonly updatedAt: Date;
+  readonly appTag: string | null;
+  readonly meta: Record<string, unknown>;
+  readonly invariants: readonly string[];
+}
+/**
+ * One applied migration edge from the per-space ledger journal.
+ * Returned by `readLedger` in append (apply) order.
+ */
+interface LedgerEntryRecord {
+  readonly space: string;
+  readonly migrationName: string;
+  readonly migrationHash: string;
+  readonly from: string | null;
+  readonly to: string;
+  readonly appliedAt: Date;
+  readonly operationCount: number;
+}
+//#endregion
+//#region src/value-set-ref.d.ts
+/**
+ * Entity coordinate for a domain enum or storage value-set reference.
+ *
+ * Field-name identity with the framework's `EntityCoordinate` type
+ * (packages/1-framework/1-core/framework-components/src/ir/storage.ts).
+ * Foundation-contract cannot import framework-components (dependency points
+ * the other way), so this is a standalone mirror of that shape plus the
+ * cross-space discriminator.
+ *
+ * One-vocabulary rule (ADR 224): `entityKind` is equal to the entries slot
+ * key the referenced entity lives under — `'enum'` for domain's `enum` slot,
+ * `'valueSet'` for storage's `entries.valueSet` slot. No consumer-side
+ * translation between the kind string and the slot key.
+ *
+ * Every `valueSet` reference is intra-plane (domain field → domain enum;
+ * storage column/check → storage value-set). The directional invariant:
+ * domain may reference storage; storage may never reference domain.
+ *
+ * `namespaceId` admits the `UNBOUND_NAMESPACE_ID` (`__unbound__`) sentinel
+ * for single-namespace (unbound) references.
+ *
+ * `spaceId` is the cross-space discriminator: absent ⇒ local (same
+ * contract-space); present ⇒ cross-space. No separate tag field.
+ */
+interface ValueSetRef {
+  readonly plane: 'domain' | 'storage';
+  readonly namespaceId: string;
+  readonly entityKind: 'enum' | 'valueSet';
+  readonly entityName: string;
+  readonly spaceId?: string;
+}
+//#endregion
+//#region src/domain-types.d.ts
+type ScalarFieldType = {
+  readonly kind: 'scalar';
+  readonly codecId: string;
+  readonly typeParams?: Record<string, unknown>;
+};
+type ValueObjectFieldType = {
+  readonly kind: 'valueObject';
+  readonly name: string;
+};
+type UnionFieldType = {
+  readonly kind: 'union';
+  readonly members: ReadonlyArray<ScalarFieldType | ValueObjectFieldType>;
+};
+type ContractFieldType = ScalarFieldType | ValueObjectFieldType | UnionFieldType;
+type ContractField = {
+  readonly nullable: boolean;
+  readonly type: ContractFieldType;
+  readonly many?: true;
+  readonly dict?: true;
+  readonly valueSet?: ValueSetRef;
+};
+/**
+ * A domain enum: an ordered set of named members, each with a codec-encoded
+ * value. The `codecId` identifies the codec used to encode member values in
+ * storage. The `members` array is ordered (declaration order is preserved).
+ */
+type ContractEnum = {
+  readonly codecId: string;
+  readonly members: readonly {
+    readonly name: string;
+    readonly value: JsonValue;
+  }[];
+};
+type ContractRelationOn = {
+  readonly localFields: readonly string[];
+  readonly targetFields: readonly string[];
+};
+type ContractRelationThrough = {
+  readonly table: string;
+  readonly namespaceId: string;
+  readonly parentColumns: readonly string[];
+  readonly childColumns: readonly string[];
+  readonly targetColumns: readonly string[];
+};
+type ContractManyToManyRelation = {
+  readonly to: CrossReference;
+  readonly cardinality: 'N:M';
+  readonly on: ContractRelationOn;
+  readonly through: ContractRelationThrough;
+};
+type ContractNonJunctionRelation = {
+  readonly to: CrossReference;
+  readonly cardinality: '1:1' | '1:N' | 'N:1';
+  readonly on: ContractRelationOn;
+  readonly through?: never;
+};
+type ContractReferenceRelation = ContractManyToManyRelation | ContractNonJunctionRelation;
+type ContractEmbedRelation = {
+  readonly to: CrossReference;
+  readonly cardinality: '1:1' | '1:N';
+};
+type ContractRelation = ContractReferenceRelation | ContractEmbedRelation;
+type ContractDiscriminator = {
+  readonly field: string;
+};
+type ContractVariantEntry = {
+  readonly value: string;
+};
+type ContractValueObject = {
+  readonly fields: Record<string, ContractField>;
+};
+type ModelStorageBase = Readonly<Record<string, unknown>>;
+interface ContractModelBase<TModelStorage extends ModelStorageBase = ModelStorageBase> {
+  readonly fields: Record<string, ContractField>;
+  readonly relations: Record<string, ContractRelation>;
+  readonly storage: TModelStorage;
+  readonly discriminator?: ContractDiscriminator;
+  readonly variants?: Record<string, ContractVariantEntry>;
+  readonly base?: CrossReference;
+  readonly owner?: string;
+}
+interface ContractModel<TModelStorage extends ModelStorageBase = ModelStorageBase> extends ContractModelBase<TModelStorage> {
+  readonly fields: Record<string, ContractField>;
+}
+type ReferenceRelationKeys<TModels extends Record<string, {
+  readonly relations: Record<string, ContractRelation>;
+}>, ModelName extends string & keyof TModels> = { [K in keyof TModels[ModelName]['relations']]: TModels[ModelName]['relations'][K] extends ContractReferenceRelation ? K : never }[keyof TModels[ModelName]['relations']];
+type EmbedRelationKeys<TModels extends Record<string, {
+  readonly relations: Record<string, ContractRelation>;
+}>, ModelName extends string & keyof TModels> = { [K in keyof TModels[ModelName]['relations']]: TModels[ModelName]['relations'][K] extends ContractReferenceRelation ? never : K }[keyof TModels[ModelName]['relations']];
+//#endregion
+//#region src/domain-envelope.d.ts
+/**
+ * One namespace's application-domain entities — models and optional value
+ * objects keyed by entity name within that namespace coordinate.
+ */
+interface ApplicationDomainNamespace<TModels extends Record<string, ContractModelBase> = Record<string, ContractModelBase>> {
+  readonly models: TModels;
+  readonly valueObjects?: Record<string, ContractValueObject>;
+  readonly enum?: Record<string, ContractEnum>;
+}
+/**
+ * Application-domain envelope: entity content keyed by namespace id.
+ * Mirrors the storage plane's `namespaces` segment (ADR 221).
+ */
+interface ApplicationDomain<TModels extends Record<string, ContractModelBase> = Record<string, ContractModelBase>> {
+  readonly namespaces: Readonly<Record<string, ApplicationDomainNamespace<TModels>>>;
+}
+type ContractWithDomain = {
+  readonly domain: ApplicationDomain;
+};
+//#endregion
+export { executionHash as $, ColumnDefaultLiteralValue as A, FieldType as B, UnionFieldType as C, Brand as D, $ as E, ExecutionMutationDefault as F, PlanMeta as G, JsonPrimitive as H, ExecutionMutationDefaultPhases as I, StorageBase as J, ProfileHashBase as K, ExecutionMutationDefaultValue as L, DocCollection as M, DocIndex as N, ColumnDefault as O, ExecutionHashBase as P, coreHash as Q, ExecutionSection as R, ScalarFieldType as S, ValueSetRef as T, JsonValue as U, GeneratedValueSpec as V, LedgerEntryRecord as W, StorageHashBase as X, StorageEntitySlot as Y, StorageNamespace as Z, ContractValueObject as _, ContractEmbedRelation as a, CrossReferenceSchema as at, ModelStorageBase as b, ContractFieldType as c, asNamespaceId as ct, ContractModelBase as d, isColumnDefault as et, ContractNonJunctionRelation as f, ContractRelationThrough as g, ContractRelationOn as h, ContractDiscriminator as i, CrossReference as it, ContractMarkerRecord as j, ColumnDefaultLiteralInputValue as k, ContractManyToManyRelation as l, ContractRelation as m, ApplicationDomainNamespace as n, isExecutionMutationDefaultValue as nt, ContractEnum as o, crossRef as ot, ContractReferenceRelation as p, Source as q, ContractWithDomain as r, profileHash as rt, ContractField as s, NamespaceId as st, ApplicationDomain as t, isColumnDefaultLiteralInputValue as tt, ContractModel as u, ContractVariantEntry as v, ValueObjectFieldType as w, ReferenceRelationKeys as x, EmbedRelationKeys as y, Expr as z };
+//# sourceMappingURL=domain-envelope-Czz8UMhU.d.mts.map

package/dist/domain-envelope-Czz8UMhU.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-envelope-Czz8UMhU.d.mts","names":[],"sources":["../src/namespace-id.ts","../src/cross-reference.ts","../src/types.ts","../src/value-set-ref.ts","../src/domain-types.ts","../src/domain-envelope.ts"],"mappings":"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"}

package/dist/enum-accessor.d.mts

@@ -0,0 +1,93 @@
+import { t as Contract } from "./contract-types-ci3TUzpo.mjs";
+import { U as JsonValue, o as ContractEnum } from "./domain-envelope-Czz8UMhU.mjs";
+
+//#region src/enum-accessor.d.ts
+/**
+ * Runtime view of a domain enum, built at the client from the emitted
+ * `ContractEnum` JSON (codec-encoded `JsonValue` members, literal types erased).
+ *
+ * This deliberately mirrors the accessor shape of the authoring-time
+ * `EnumTypeHandle` (in `contract-ts`) rather than reusing it: that handle carries
+ * the literal value generics and lives in the authoring layer, which the
+ * foundation layer cannot depend on. The two are the same surface seen from the
+ * two planes — authoring (typed) and runtime (validated JSON).
+ */
+interface EnumAccessor {
+  readonly values: readonly JsonValue[];
+  readonly names: readonly string[];
+  readonly members: Readonly<Record<string, JsonValue>>;
+  has(v: JsonValue): boolean;
+  hasName(name: string): boolean;
+  nameOf(v: JsonValue): string | undefined;
+  ordinalOf(v: JsonValue): number;
+}
+declare function createEnumAccessor(contractEnum: ContractEnum): EnumAccessor;
+/**
+ * Build the enum-accessor map for a single namespace, keyed by enum name.
+ * Each namespace facet exposes only its own enums — the IR keys enums under
+ * `domain.namespaces[ns].enum`, so the same name in two namespaces resolves
+ * independently rather than colliding in one flat map.
+ */
+declare function buildEnumsMapForNamespace(domain: {
+  readonly namespaces: Readonly<Record<string, {
+    readonly enum?: Readonly<Record<string, ContractEnum>>;
+  }>>;
+}, namespaceId: string): Record<string, EnumAccessor>;
+/**
+ * Build the enum-accessor map for every namespace of a domain, keyed by
+ * namespace id then enum name. This is the lane-agnostic enum surface the
+ * `db.enums` facade member exposes: enums are contract metadata, the same
+ * whether reached through the sql lane or the orm lane, so the facade builds
+ * this once and projects it per target.
+ */
+declare function buildNamespacedEnums(domain: {
+  readonly namespaces: Readonly<Record<string, {
+    readonly enum?: Readonly<Record<string, ContractEnum>>;
+  }>>;
+}): Record<string, Record<string, EnumAccessor>>;
+type Present<T> = Exclude<T, undefined>;
+type EnumMemberEntry = {
+  readonly name: string;
+  readonly value: JsonValue;
+};
+type EnumEntry = {
+  readonly members: readonly EnumMemberEntry[];
+};
+type EnumEntryValues<Entry extends EnumEntry> = { readonly [I in keyof Entry['members']]: Entry['members'][I] extends EnumMemberEntry ? Entry['members'][I]['value'] : never };
+type EnumEntryNames<Entry extends EnumEntry> = { readonly [I in keyof Entry['members']]: Entry['members'][I] extends EnumMemberEntry ? Entry['members'][I]['name'] : never };
+type EnumEntryMembers<Entry extends EnumEntry> = { readonly [M in Entry['members'][number] as M['name']]: M['value'] };
+type ContractEnumAccessor<Entry extends EnumEntry> = {
+  readonly values: EnumEntryValues<Entry>;
+  readonly names: EnumEntryNames<Entry>;
+  readonly members: EnumEntryMembers<Entry>; /** Returns true and narrows `v` to the enum's value union when `v` is a declared member value. */
+  has(v: JsonValue): v is EnumEntryValues<Entry>[number]; /** Returns true and narrows `name` to the enum's member-name union when `name` is a declared member name. */
+  hasName(name: string): name is Extract<EnumEntryNames<Entry>[number], string>;
+  nameOf(v: EnumEntryValues<Entry>[number]): string | undefined;
+  ordinalOf(v: EnumEntryValues<Entry>[number]): number;
+};
+/**
+ * The value union for a `ContractEnumAccessor`.
+ * Use in function signatures to accept any declared enum value without re-exporting
+ * the member type alias from the accessor's generic entry.
+ */
+type EnumValues<A> = A extends {
+  readonly values: ReadonlyArray<infer V>;
+} ? V : never;
+/**
+ * The member-name union for a `ContractEnumAccessor`.
+ */
+type EnumMemberNames<A> = A extends {
+  readonly names: ReadonlyArray<infer N>;
+} ? N : never;
+type EnumEntriesToAccessors<Enums> = { readonly [K in keyof Enums]: Enums[K] extends EnumEntry ? ContractEnumAccessor<Enums[K]> : never };
+type BuiltEnumAccessorsOf<TContract> = TContract extends {
+  readonly enumAccessors: infer A;
+} ? A : Record<never, never>;
+type NamespaceEnumEntries<TNamespace> = TNamespace extends {
+  readonly enum?: infer E;
+} ? unknown extends E ? Record<never, never> : Present<E> : Record<never, never>;
+type NamespaceEnumAccessors<TContract extends Contract, NsId extends keyof TContract['domain']['namespaces']> = EnumEntriesToAccessors<NamespaceEnumEntries<TContract['domain']['namespaces'][NsId]>> & BuiltEnumAccessorsOf<TContract>;
+type NamespacedEnums<TContract extends Contract> = { readonly [Ns in keyof TContract['domain']['namespaces']]: NamespaceEnumAccessors<TContract, Ns> };
+//#endregion
+export { type ContractEnumAccessor, type EnumAccessor, type EnumMemberNames, type EnumValues, type NamespaceEnumAccessors, type NamespacedEnums, buildEnumsMapForNamespace, buildNamespacedEnums, createEnumAccessor };
+//# sourceMappingURL=enum-accessor.d.mts.map

package/dist/enum-accessor.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-accessor.d.mts","names":[],"sources":["../src/enum-accessor.ts"],"mappings":";;;;;AAcA;;;;;;;;;UAAiB,YAAA;EAAA,SACN,MAAA,WAAiB,SAAA;EAAA,SACjB,KAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,SAAA;EAC1C,GAAA,CAAI,CAAA,EAAG,SAAA;EACP,OAAA,CAAQ,IAAA;EACR,MAAA,CAAO,CAAA,EAAG,SAAA;EACV,SAAA,CAAU,CAAA,EAAG,SAAA;AAAA;AAAA,iBAGC,kBAAA,CAAmB,YAAA,EAAc,YAAA,GAAe,YAAY;;;;;;;iBA6B5D,yBAAA,CACd,MAAA;EAAA,SACW,UAAA,EAAY,QAAA,CACnB,MAAA;IAAA,SAA0B,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA;AAAA,GAG7D,WAAA,WACC,MAAA,SAAe,YAAA;;AAvCM;AAGxB;;;;;iBAsDgB,oBAAA,CAAqB,MAAA;EAAA,SAC1B,UAAA,EAAY,QAAA,CACnB,MAAA;IAAA,SAA0B,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA;AAAA,IAEzD,MAAA,SAAe,MAAA,SAAe,YAAA;AAAA,KA0B7B,OAAA,MAAa,OAAO,CAAC,CAAA;AAAA,KAKrB,eAAA;EAAA,SAA6B,IAAA;EAAA,SAAuB,KAAA,EAAO,SAAS;AAAA;AAAA,KACpE,SAAA;EAAA,SAAuB,OAAA,WAAkB,eAAe;AAAA;AAAA,KAExD,eAAA,eAA8B,SAAA,2BACZ,KAAA,cAAmB,KAAA,YAAiB,CAAA,UAAW,eAAA,GAChE,KAAA,YAAiB,CAAA;AAAA,KAIlB,cAAA,eAA6B,SAAA,2BACX,KAAA,cAAmB,KAAA,YAAiB,CAAA,UAAW,eAAA,GAChE,KAAA,YAAiB,CAAA;AAAA,KAIlB,gBAAA,eAA+B,SAAA,qBACnB,KAAA,uBAA4B,CAAA,WAAY,CAAA;AAAA,KAM7C,oBAAA,eAAmC,SAAA;EAAA,SACpC,MAAA,EAAQ,eAAA,CAAgB,KAAA;EAAA,SACxB,KAAA,EAAO,cAAA,CAAe,KAAA;EAAA,SACtB,OAAA,EAAS,gBAAA,CAAiB,KAAA,GA9EnB;EAgFhB,GAAA,CAAI,CAAA,EAAG,SAAA,GAAY,CAAA,IAAK,eAAA,CAAgB,KAAA,WAhFZ;EAkF5B,OAAA,CAAQ,IAAA,WAAe,IAAA,IAAQ,OAAA,CAAQ,cAAA,CAAe,KAAA;EACtD,MAAA,CAAO,CAAA,EAAG,eAAA,CAAgB,KAAA;EAC1B,SAAA,CAAU,CAAA,EAAG,eAAA,CAAgB,KAAA;AAAA;;;;;;KAQnB,UAAA,MAAgB,CAAA;EAAA,SAAqB,MAAA,EAAQ,aAAa;AAAA,IAAc,CAAA;;;;KAKxE,eAAA,MAAqB,CAAA;EAAA,SAAqB,KAAA,EAAO,aAAa;AAAA,IAAc,CAAA;AAAA,KAEnF,sBAAA,iCACkB,KAAA,GAAQ,KAAA,CAAM,CAAA,UAAW,SAAA,GAAY,oBAAA,CAAqB,KAAA,CAAM,CAAA;AAAA,KAGlF,oBAAA,cAAkC,SAAA;EAAA,SAC5B,aAAA;AAAA,IAEP,CAAA,GACA,MAAM;AAAA,KAEL,oBAAA,eAAmC,UAAA;EAAA,SAC7B,IAAA;AAAA,oBAES,CAAA,GACd,MAAA,iBACA,OAAA,CAAQ,CAAA,IACV,MAAA;AAAA,KAKQ,sBAAA,mBACQ,QAAA,qBACC,SAAA,4BACjB,sBAAA,CAAuB,oBAAA,CAAqB,SAAA,yBAAkC,IAAA,MAChF,oBAAA,CAAqB,SAAA;AAAA,KAIX,eAAA,mBAAkC,QAAA,4BACtB,SAAA,2BAAoC,sBAAA,CAAuB,SAAA,EAAW,EAAA"}

package/dist/enum-accessor.mjs

@@ -0,0 +1,47 @@
+//#region src/enum-accessor.ts
+function createEnumAccessor(contractEnum) {
+	const values = Object.freeze(contractEnum.members.map((m) => m.value));
+	const names = Object.freeze(contractEnum.members.map((m) => m.name));
+	const members = Object.freeze(Object.fromEntries(contractEnum.members.map((m) => [m.name, m.value])));
+	const valueSet = new Set(values);
+	const nameSet = Object.freeze(new Set(names));
+	const valueToName = new Map(contractEnum.members.map((m) => [m.value, m.name]));
+	const valueToOrdinal = new Map(values.map((v, i) => [v, i]));
+	return {
+		values,
+		names,
+		members,
+		has: (v) => valueSet.has(v),
+		hasName: (name) => nameSet.has(name),
+		nameOf: (v) => valueToName.get(v),
+		ordinalOf: (v) => valueToOrdinal.get(v) ?? -1
+	};
+}
+/**
+* Build the enum-accessor map for a single namespace, keyed by enum name.
+* Each namespace facet exposes only its own enums — the IR keys enums under
+* `domain.namespaces[ns].enum`, so the same name in two namespaces resolves
+* independently rather than colliding in one flat map.
+*/
+function buildEnumsMapForNamespace(domain, namespaceId) {
+	const result = {};
+	const namespace = domain.namespaces[namespaceId];
+	if (namespace?.enum) for (const [name, contractEnum] of Object.entries(namespace.enum)) result[name] = createEnumAccessor(contractEnum);
+	return result;
+}
+/**
+* Build the enum-accessor map for every namespace of a domain, keyed by
+* namespace id then enum name. This is the lane-agnostic enum surface the
+* `db.enums` facade member exposes: enums are contract metadata, the same
+* whether reached through the sql lane or the orm lane, so the facade builds
+* this once and projects it per target.
+*/
+function buildNamespacedEnums(domain) {
+	const result = {};
+	for (const namespaceId of Object.keys(domain.namespaces)) result[namespaceId] = buildEnumsMapForNamespace(domain, namespaceId);
+	return result;
+}
+//#endregion
+export { buildEnumsMapForNamespace, buildNamespacedEnums, createEnumAccessor };
+
+//# sourceMappingURL=enum-accessor.mjs.map

package/dist/enum-accessor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-accessor.mjs","names":[],"sources":["../src/enum-accessor.ts"],"sourcesContent":["import type { Contract } from './contract-types';\nimport type { ContractEnum } from './domain-types';\nimport type { JsonValue } from './types';\n\n/**\n * Runtime view of a domain enum, built at the client from the emitted\n * `ContractEnum` JSON (codec-encoded `JsonValue` members, literal types erased).\n *\n * This deliberately mirrors the accessor shape of the authoring-time\n * `EnumTypeHandle` (in `contract-ts`) rather than reusing it: that handle carries\n * the literal value generics and lives in the authoring layer, which the\n * foundation layer cannot depend on. The two are the same surface seen from the\n * two planes — authoring (typed) and runtime (validated JSON).\n */\nexport interface EnumAccessor {\n  readonly values: readonly JsonValue[];\n  readonly names: readonly string[];\n  readonly members: Readonly<Record<string, JsonValue>>;\n  has(v: JsonValue): boolean;\n  hasName(name: string): boolean;\n  nameOf(v: JsonValue): string | undefined;\n  ordinalOf(v: JsonValue): number;\n}\n\nexport function createEnumAccessor(contractEnum: ContractEnum): EnumAccessor {\n  const values = Object.freeze(contractEnum.members.map((m) => m.value));\n  const names = Object.freeze(contractEnum.members.map((m) => m.name));\n  const members: Readonly<Record<string, JsonValue>> = Object.freeze(\n    Object.fromEntries(contractEnum.members.map((m) => [m.name, m.value])),\n  );\n\n  const valueSet = new Set(values);\n  const nameSet = Object.freeze(new Set(names));\n  const valueToName = new Map(contractEnum.members.map((m) => [m.value, m.name]));\n  const valueToOrdinal = new Map(values.map((v, i) => [v, i]));\n\n  return {\n    values,\n    names,\n    members,\n    has: (v: JsonValue) => valueSet.has(v),\n    hasName: (name: string) => nameSet.has(name),\n    nameOf: (v: JsonValue) => valueToName.get(v),\n    ordinalOf: (v: JsonValue) => valueToOrdinal.get(v) ?? -1,\n  };\n}\n\n/**\n * Build the enum-accessor map for a single namespace, keyed by enum name.\n * Each namespace facet exposes only its own enums — the IR keys enums under\n * `domain.namespaces[ns].enum`, so the same name in two namespaces resolves\n * independently rather than colliding in one flat map.\n */\nexport function buildEnumsMapForNamespace(\n  domain: {\n    readonly namespaces: Readonly<\n      Record<string, { readonly enum?: Readonly<Record<string, ContractEnum>> }>\n    >;\n  },\n  namespaceId: string,\n): Record<string, EnumAccessor> {\n  const result: Record<string, EnumAccessor> = {};\n  const namespace = domain.namespaces[namespaceId];\n  if (namespace?.enum) {\n    for (const [name, contractEnum] of Object.entries(namespace.enum)) {\n      result[name] = createEnumAccessor(contractEnum);\n    }\n  }\n  return result;\n}\n\n/**\n * Build the enum-accessor map for every namespace of a domain, keyed by\n * namespace id then enum name. This is the lane-agnostic enum surface the\n * `db.enums` facade member exposes: enums are contract metadata, the same\n * whether reached through the sql lane or the orm lane, so the facade builds\n * this once and projects it per target.\n */\nexport function buildNamespacedEnums(domain: {\n  readonly namespaces: Readonly<\n    Record<string, { readonly enum?: Readonly<Record<string, ContractEnum>> }>\n  >;\n}): Record<string, Record<string, EnumAccessor>> {\n  const result: Record<string, Record<string, EnumAccessor>> = {};\n  for (const namespaceId of Object.keys(domain.namespaces)) {\n    result[namespaceId] = buildEnumsMapForNamespace(domain, namespaceId);\n  }\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Type-level projection of the namespaced enum surface.\n//\n// These types derive the literal-preserving accessor shape from the contract,\n// hung off the `db.enums` facade map (`db.enums.<ns>.<Name>`). They are the\n// same accessors the runtime builds above, but typed from the two emission\n// paths:\n//   - Emitted contracts carry the literal enum entries under\n//     `domain.namespaces[ns].enum`; each maps to a `ContractEnumAccessor`.\n//   - The no-emit (built) contract carries them flat on `enumAccessors`\n//     (already accessor-shaped, literal-preserving), since its built domain\n//     type does not narrow `namespaces[ns].enum`. All authored enums land in\n//     the single built namespace, so exposing the flat map per namespace is\n//     correct there.\n// Only `SqlContractResult` carries `enumAccessors`; emitted contracts never\n// do, so the two carriers never overlap.\n// ---------------------------------------------------------------------------\n\ntype Present<T> = Exclude<T, undefined>;\n\n// A domain enum entry as carried in `domain.namespaces[ns].enum[name]`: an\n// ordered member tuple. The no-emit (built) path preserves the literal member\n// values so the derived accessor keeps its literal `values`/`names`/`members`.\ntype EnumMemberEntry = { readonly name: string; readonly value: JsonValue };\ntype EnumEntry = { readonly members: readonly EnumMemberEntry[] };\n\ntype EnumEntryValues<Entry extends EnumEntry> = {\n  readonly [I in keyof Entry['members']]: Entry['members'][I] extends EnumMemberEntry\n    ? Entry['members'][I]['value']\n    : never;\n};\n\ntype EnumEntryNames<Entry extends EnumEntry> = {\n  readonly [I in keyof Entry['members']]: Entry['members'][I] extends EnumMemberEntry\n    ? Entry['members'][I]['name']\n    : never;\n};\n\ntype EnumEntryMembers<Entry extends EnumEntry> = {\n  readonly [M in Entry['members'][number] as M['name']]: M['value'];\n};\n\n// The runtime accessor shape for one enum, with literal `values`/`names`/\n// `members` derived from the entry's member tuple. Mirrors `EnumAccessor`'s\n// runtime surface and the authoring `EnumTypeHandle` accessor.\nexport type ContractEnumAccessor<Entry extends EnumEntry> = {\n  readonly values: EnumEntryValues<Entry>;\n  readonly names: EnumEntryNames<Entry>;\n  readonly members: EnumEntryMembers<Entry>;\n  /** Returns true and narrows `v` to the enum's value union when `v` is a declared member value. */\n  has(v: JsonValue): v is EnumEntryValues<Entry>[number];\n  /** Returns true and narrows `name` to the enum's member-name union when `name` is a declared member name. */\n  hasName(name: string): name is Extract<EnumEntryNames<Entry>[number], string>;\n  nameOf(v: EnumEntryValues<Entry>[number]): string | undefined;\n  ordinalOf(v: EnumEntryValues<Entry>[number]): number;\n};\n\n/**\n * The value union for a `ContractEnumAccessor`.\n * Use in function signatures to accept any declared enum value without re-exporting\n * the member type alias from the accessor's generic entry.\n */\nexport type EnumValues<A> = A extends { readonly values: ReadonlyArray<infer V> } ? V : never;\n\n/**\n * The member-name union for a `ContractEnumAccessor`.\n */\nexport type EnumMemberNames<A> = A extends { readonly names: ReadonlyArray<infer N> } ? N : never;\n\ntype EnumEntriesToAccessors<Enums> = {\n  readonly [K in keyof Enums]: Enums[K] extends EnumEntry ? ContractEnumAccessor<Enums[K]> : never;\n};\n\ntype BuiltEnumAccessorsOf<TContract> = TContract extends {\n  readonly enumAccessors: infer A;\n}\n  ? A\n  : Record<never, never>;\n\ntype NamespaceEnumEntries<TNamespace> = TNamespace extends {\n  readonly enum?: infer E;\n}\n  ? unknown extends E\n    ? Record<never, never>\n    : Present<E>\n  : Record<never, never>;\n\n// The per-namespace enum accessors. Each namespace exposes only its own enums\n// (the IR's `domain.namespaces[ns].enum`), so the same enum name in two\n// namespaces resolves to each namespace's own accessor.\nexport type NamespaceEnumAccessors<\n  TContract extends Contract,\n  NsId extends keyof TContract['domain']['namespaces'],\n> = EnumEntriesToAccessors<NamespaceEnumEntries<TContract['domain']['namespaces'][NsId]>> &\n  BuiltEnumAccessorsOf<TContract>;\n\n// The lane-agnostic enum surface exposed on the `db.enums` facade member: a\n// namespace-keyed map projected per target exactly like `db.sql` / `db.orm`.\nexport type NamespacedEnums<TContract extends Contract> = {\n  readonly [Ns in keyof TContract['domain']['namespaces']]: NamespaceEnumAccessors<TContract, Ns>;\n};\n"],"mappings":";AAwBA,SAAgB,mBAAmB,cAA0C;CAC3E,MAAM,SAAS,OAAO,OAAO,aAAa,QAAQ,KAAK,MAAM,EAAE,KAAK,CAAC;CACrE,MAAM,QAAQ,OAAO,OAAO,aAAa,QAAQ,KAAK,MAAM,EAAE,IAAI,CAAC;CACnE,MAAM,UAA+C,OAAO,OAC1D,OAAO,YAAY,aAAa,QAAQ,KAAK,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CACvE;CAEA,MAAM,WAAW,IAAI,IAAI,MAAM;CAC/B,MAAM,UAAU,OAAO,OAAO,IAAI,IAAI,KAAK,CAAC;CAC5C,MAAM,cAAc,IAAI,IAAI,aAAa,QAAQ,KAAK,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;CAC9E,MAAM,iBAAiB,IAAI,IAAI,OAAO,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;CAE3D,OAAO;EACL;EACA;EACA;EACA,MAAM,MAAiB,SAAS,IAAI,CAAC;EACrC,UAAU,SAAiB,QAAQ,IAAI,IAAI;EAC3C,SAAS,MAAiB,YAAY,IAAI,CAAC;EAC3C,YAAY,MAAiB,eAAe,IAAI,CAAC,KAAK;CACxD;AACF;;;;;;;AAQA,SAAgB,0BACd,QAKA,aAC8B;CAC9B,MAAM,SAAuC,CAAC;CAC9C,MAAM,YAAY,OAAO,WAAW;CACpC,IAAI,WAAW,MACb,KAAK,MAAM,CAAC,MAAM,iBAAiB,OAAO,QAAQ,UAAU,IAAI,GAC9D,OAAO,QAAQ,mBAAmB,YAAY;CAGlD,OAAO;AACT;;;;;;;;AASA,SAAgB,qBAAqB,QAIY;CAC/C,MAAM,SAAuD,CAAC;CAC9D,KAAK,MAAM,eAAe,OAAO,KAAK,OAAO,UAAU,GACrD,OAAO,eAAe,0BAA0B,QAAQ,WAAW;CAErE,OAAO;AACT"}