@prisma-next/sql-contract 0.8.0 → 0.9.0-dev.2

package/dist/types-B0lbr9cb.d.mts

@@ -0,0 +1,498 @@
+import { IRNodeBase, Namespace, NamespaceBase, Storage, StorageType } from "@prisma-next/framework-components/ir";
+import { ColumnDefault, StorageHashBase } from "@prisma-next/contract/types";
+import { CodecTrait } from "@prisma-next/framework-components/codec";
+
+//#region src/ir/sql-node.d.ts
+/**
+ * SQL family IR node base. Carries the family-level `kind` discriminator
+ * `'sql'` and inherits the framework's `freezeNode` affordance.
+ *
+ * Single family-level discriminator (not per-leaf) reflects the fact that
+ * SQL IR has no polymorphic dispatch today — verifiers and serializers
+ * walk by structural position (`storage.tables[name].columns[name]`),
+ * not by inspecting `kind`. The abstract bar for per-leaf discriminators
+ * isn't earned until a future polymorphic consumer arrives.
+ *
+ * `kind` is installed as a non-enumerable own property on every instance,
+ * which keeps three things clean simultaneously:
+ *
+ * - `JSON.stringify(node)` produces the canonical pre-lift JSON envelope
+ *   shape (no `kind` field), so emitted contract.json files and the
+ *   `validateSqlContractFully` arktype schemas stay unchanged.
+ * - Test assertions that use `toEqual({...})` against the pre-lift flat
+ *   shape continue to pass — only enumerable own properties are
+ *   compared.
+ * - Direct access (`node.kind`) and runtime narrowing
+ *   (`if (node.kind === 'sql')`) still work, so future polymorphic
+ *   dispatch can begin reading `kind` without a runtime change.
+ *
+ * Future per-leaf overrides land cleanly: a class that gains a
+ * polymorphic-dispatch consumer (e.g. an enum type instance walked
+ * alongside other types) overrides `kind` with its narrower literal
+ * at that leaf level. Per-leaf overrides will use enumerable kind
+ * (matching the Mongo per-class-discriminator precedent) because they
+ * encode dispatch-relevant information that callers need to see in
+ * JSON envelopes; the family-level `'sql'` is uniform across all SQL
+ * IR and carries no dispatch-relevant information.
+ */
+declare abstract class SqlNode extends IRNodeBase {
+  readonly kind?: string;
+  constructor();
+}
+//#endregion
+//#region src/ir/foreign-key-references.d.ts
+interface ForeignKeyReferencesInput {
+  readonly table: string;
+  readonly columns: readonly string[];
+}
+/**
+ * SQL Contract IR node for the referenced side of a foreign key.
+ *
+ * The class is shaped around single-namespace references today; a
+ * future milestone introduces a cross-namespace coordinate on top of
+ * `(table, columns)` when namespace-keyed storage lands.
+ */
+declare class ForeignKeyReferences extends SqlNode {
+  readonly table: string;
+  readonly columns: readonly string[];
+  constructor(input: ForeignKeyReferencesInput);
+}
+//#endregion
+//#region src/ir/foreign-key.d.ts
+type ReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+interface ForeignKeyInput {
+  readonly columns: readonly string[];
+  readonly references: ForeignKeyReferences | ForeignKeyReferencesInput;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  /** Whether to emit FK constraint DDL (ALTER TABLE … ADD CONSTRAINT … FOREIGN KEY). */
+  readonly constraint: boolean;
+  /** Whether to emit a backing index for the FK columns. */
+  readonly index: boolean;
+}
+/**
+ * SQL Contract IR node for a table-level foreign-key declaration.
+ *
+ * The nested `references` field is normalised to a
+ * {@link ForeignKeyReferences} instance inside the constructor so
+ * downstream walks see a uniform AST regardless of whether the input
+ * was a JSON literal or an already-constructed class instance.
+ */
+declare class ForeignKey extends SqlNode {
+  readonly columns: readonly string[];
+  readonly references: ForeignKeyReferences;
+  readonly constraint: boolean;
+  readonly index: boolean;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  constructor(input: ForeignKeyInput);
+}
+//#endregion
+//#region src/ir/postgres-enum-storage-entry.d.ts
+/**
+ * Discriminator literal for the Postgres-enum variant on the polymorphic
+ * `SqlStorage.types` slot.
+ *
+ * Enums are a target-level concept: Postgres ships native
+ * `CREATE TYPE … AS ENUM` while other SQL targets approximate enums via
+ * constraints. The literal lives at the SQL family layer because every
+ * SQL-family consumer (verifier, planner, lowering, …) needs to
+ * discriminate enum-typed slot entries from codec-typed ones. The
+ * concrete IR class (`PostgresEnumType`) lives in the target-postgres
+ * package and implements this structural contract; cross-domain
+ * layering rules forbid the SQL family from importing the concrete
+ * target class directly, so the discriminator and structural interface
+ * carry the dispatch.
+ */
+declare const POSTGRES_ENUM_KIND: "postgres-enum";
+/**
+ * Structural contract every Postgres-enum slot entry honours — both
+ * the live `PostgresEnumType` IR-class instance and the raw JSON
+ * envelope shape that survives `JSON.stringify` round-trips. SQL
+ * family-layer dispatch narrows polymorphic `StorageType` slot
+ * entries to this shape via `isPostgresEnumStorageEntry`.
+ *
+ * The `codecBinding` field is accessor-shaped (live class instance) on
+ * the IR class and undefined on the raw JSON envelope; consumers that
+ * need it must guard for its presence (the JSON path synthesises an
+ * equivalent shape from `codecId` + `values`).
+ */
+interface PostgresEnumStorageEntry extends StorageType {
+  readonly kind: typeof POSTGRES_ENUM_KIND;
+  readonly name: string;
+  readonly nativeType: string;
+  readonly values: readonly string[];
+  /**
+   * Enumerable own property on the persisted JSON envelope; the live
+   * IR-class instance carries it too. Family-shared dispatch sites
+   * read `codecId` directly rather than going through the IR-class
+   * `codecBinding` accessor (which lives on the prototype and isn't
+   * present on raw JSON envelopes).
+   */
+  readonly codecId: string;
+}
+/**
+ * Narrow a polymorphic `StorageType` entry to the Postgres-enum shape
+ * via its enumerable `kind` discriminator. Type guard returns true for
+ * both live `PostgresEnumType` instances and raw JSON envelopes.
+ */
+declare function isPostgresEnumStorageEntry(value: unknown): value is PostgresEnumStorageEntry;
+//#endregion
+//#region src/ir/primary-key.d.ts
+interface PrimaryKeyInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+/**
+ * SQL Contract IR node for a table's primary-key constraint.
+ */
+declare class PrimaryKey extends SqlNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  constructor(input: PrimaryKeyInput);
+}
+//#endregion
+//#region src/ir/sql-index.d.ts
+interface IndexInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+}
+/**
+ * SQL Contract IR node for a table-level secondary index.
+ *
+ * Note that this class shadows the global TypeScript `Index` lib type
+ * at the family-shared name; consumer files that need both should
+ * alias one (e.g.
+ * `import { Index as SqlIndexNode } from '@prisma-next/sql-contract/types'`).
+ */
+declare class Index extends SqlNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+  constructor(input: IndexInput);
+}
+//#endregion
+//#region src/ir/storage-column.d.ts
+/**
+ * Hydration / construction input shape for {@link StorageColumn}. Mirrors
+ * the on-disk storage JSON envelope exactly so the family-base
+ * serializer's hydration walker can hand an arktype-validated literal
+ * straight to `new`.
+ *
+ * `typeParams` and `typeRef` remain mutually exclusive (one or the
+ * other, not both); the constructor preserves whichever caller-side
+ * choice the input encodes.
+ */
+interface StorageColumnInput {
+  readonly nativeType: string;
+  readonly codecId: string;
+  readonly nullable: boolean;
+  readonly typeParams?: Record<string, unknown>;
+  readonly typeRef?: string;
+  readonly default?: ColumnDefault;
+}
+/**
+ * SQL Contract IR node for a single column entry in `StorageTable.columns`.
+ *
+ * Single concrete family-shared class — every SQL target reads the
+ * same column shape today, so there is no per-target subclass. The
+ * class type accepts any caller that constructs via
+ * `new StorageColumn(input)`; literal construction sites must pass
+ * through the constructor or the family-base hydration walker.
+ *
+ * The column's `name` is not on the class — columns are keyed by name
+ * in the parent `StorageTable.columns: Record<string, StorageColumn>`
+ * map, so a `name` field would be redundant with the key.
+ */
+declare class StorageColumn extends SqlNode {
+  readonly nativeType: string;
+  readonly codecId: string;
+  readonly nullable: boolean;
+  readonly typeParams?: Record<string, unknown>;
+  readonly typeRef?: string;
+  readonly default?: ColumnDefault;
+  constructor(input: StorageColumnInput);
+}
+//#endregion
+//#region src/ir/unique-constraint.d.ts
+interface UniqueConstraintInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+/**
+ * SQL Contract IR node for a table-level unique constraint.
+ */
+declare class UniqueConstraint extends SqlNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  constructor(input: UniqueConstraintInput);
+}
+//#endregion
+//#region src/ir/storage-table.d.ts
+interface StorageTableInput {
+  readonly columns: Record<string, StorageColumn | StorageColumnInput>;
+  readonly primaryKey?: PrimaryKey | PrimaryKeyInput;
+  readonly uniques: ReadonlyArray<UniqueConstraint | UniqueConstraintInput>;
+  readonly indexes: ReadonlyArray<Index | IndexInput>;
+  readonly foreignKeys: ReadonlyArray<ForeignKey | ForeignKeyInput>;
+}
+/**
+ * SQL Contract IR node for a single table entry in `SqlStorage.tables`.
+ *
+ * The constructor normalises nested IR-class fields (columns, primary
+ * key, uniques, indexes, foreign keys) into the appropriate class
+ * instances so downstream walks see a uniform AST regardless of whether
+ * the input was a JSON literal or an already-constructed class.
+ *
+ * The table's `name` is not on the class — tables are keyed by name in
+ * the parent `SqlStorage.tables: Record<string, StorageTable>` map.
+ * A future namespace-aware milestone will add a `namespaceId` field
+ * when namespace-keyed storage lands; today's single-namespace shape
+ * needs neither field.
+ */
+declare class StorageTable extends SqlNode {
+  readonly columns: Readonly<Record<string, StorageColumn>>;
+  readonly uniques: ReadonlyArray<UniqueConstraint>;
+  readonly indexes: ReadonlyArray<Index>;
+  readonly foreignKeys: ReadonlyArray<ForeignKey>;
+  readonly primaryKey?: PrimaryKey;
+  constructor(input: StorageTableInput);
+}
+//#endregion
+//#region src/ir/storage-type-instance.d.ts
+/**
+ * Sentinel kind for the legacy codec-triple shape persisted under
+ * `SqlStorage.types`. Plain JSON-clean object literals carry this
+ * discriminator so the polymorphic slot dispatch can route them down
+ * the codec path while target-specific IR class instances (e.g. the
+ * Postgres enum class) keep their own narrower `kind` literal.
+ */
+declare const CODEC_INSTANCE_KIND: "codec-instance";
+/**
+ * Structural sub-interface of {@link StorageType} for codec-typed entries
+ * in `SqlStorage.types`. These are plain object literals — there is no
+ * runtime IR class, the JSON envelope round-trips through the slot
+ * unchanged. The `kind: 'codec-instance'` discriminator is the dispatch
+ * key that distinguishes codec-typed entries from class-instance entries
+ * (e.g. `PostgresEnumType`) sharing the polymorphic slot.
+ */
+interface StorageTypeInstance extends StorageType {
+  readonly kind: typeof CODEC_INSTANCE_KIND;
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams: Record<string, unknown>;
+}
+/**
+ * Construction-time input for a codec-triple entry. Symmetric with the
+ * structural runtime shape minus the `kind` discriminator — callers may
+ * omit `kind`; the helper {@link toStorageTypeInstance} stamps it on.
+ */
+interface StorageTypeInstanceInput {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams: Record<string, unknown>;
+}
+/**
+ * Stamp the codec-instance `kind` discriminator on a caller-supplied
+ * codec triple. Idempotent: input that already carries the discriminator
+ * passes through unchanged.
+ */
+declare function toStorageTypeInstance(input: StorageTypeInstanceInput): StorageTypeInstance;
+/**
+ * Type-guard for codec-typed entries on the polymorphic
+ * `SqlStorage.types` slot. Distinguishes `StorageTypeInstance` from
+ * class-instance kinds (e.g. `PostgresEnumType`).
+ */
+declare function isStorageTypeInstance(value: unknown): value is StorageTypeInstance;
+//#endregion
+//#region src/ir/sql-storage.d.ts
+/**
+ * Polymorphic value type for `SqlStorage.types` entries (Decision 18,
+ * Option B). The slot's framework alphabet is `StorageType` — codec
+ * triples (`StorageTypeInstance` with `kind: 'codec-instance'`) and
+ * target-specific IR class instances structurally satisfying
+ * `PostgresEnumStorageEntry` (with `kind: 'postgres-enum'`) are the
+ * two variants the SQL family ships today. The construction side also
+ * accepts {@link StorageTypeInstanceInput} so callers can pass raw
+ * codec triples; the constructor stamps the discriminator.
+ */
+type SqlStorageTypeEntry = StorageTypeInstance | PostgresEnumStorageEntry | StorageTypeInstanceInput;
+interface SqlStorageInput<THash extends string = string> {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly tables: Record<string, StorageTable | StorageTableInput>;
+  readonly types?: Record<string, SqlStorageTypeEntry>;
+  readonly namespaces?: Readonly<Record<string, Namespace>>;
+}
+/**
+ * SQL Contract IR root node for the `storage` field.
+ *
+ * Single concrete family-shared class — both Postgres and SQLite
+ * consume this same class today. Per-target storage subclasses are
+ * introduced when each target's namespace shape earns its
+ * target-specific concretion (target-specific derived fields,
+ * target-specific storage extensions).
+ *
+ * Honours the framework `Storage` interface: every SQL IR carries a
+ * `namespaces` map keyed by namespace id. The default singleton
+ * (`{ [UNSPECIFIED_NAMESPACE_ID]: SqlUnspecifiedNamespace.instance }`)
+ * binds every contract authored before per-target namespace concretions
+ * land; per-target namespace classes (`PostgresSchema.unspecified`,
+ * `SqliteUnspecifiedDatabase.instance`) earn their slots when each
+ * target's namespace shape lands.
+ *
+ * The constructor normalises nested IR-class fields (`tables`, optional
+ * `types`) into class instances so downstream walks see a uniform AST.
+ * `types` is polymorphic per Decision 18 Option B: codec-triple inputs
+ * are stamped with `kind: 'codec-instance'`; class-instance kinds
+ * (e.g. Postgres-enum entries satisfying `PostgresEnumStorageEntry`)
+ * pass through; hydration of raw JSON class-instance entries (carrying
+ * their narrower `kind` literal) is the per-target serializer's
+ * responsibility (so the family base does not import target-specific
+ * subclasses).
+ */
+declare class SqlStorage<THash extends string = string> extends SqlNode implements Storage {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly tables: Readonly<Record<string, StorageTable>>;
+  readonly namespaces: Readonly<Record<string, Namespace>>;
+  readonly types?: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+  constructor(input: SqlStorageInput<THash>);
+}
+//#endregion
+//#region src/ir/sql-unspecified-namespace.d.ts
+/**
+ * Family-layer placeholder for the SQL unspecified-namespace singleton.
+ *
+ * SQL contracts honour the framework `Storage.namespaces` invariant from
+ * the moment they appear in the IR. Today `SqlStorage` is family-shared
+ * (Postgres + SQLite consume the same class); a per-target namespace
+ * concretion (`PostgresSchema.unspecified`, `SqliteUnspecifiedDatabase.instance`)
+ * earns its existence when each target's namespace shape lands. Until
+ * then the family ships a single placeholder singleton so the JSON
+ * envelope and runtime walk are honest at every layer.
+ *
+ * The `kind` discriminator is installed as a non-enumerable own property
+ * so the JSON envelope reads `{ "id": "__unspecified__" }` — symmetric
+ * with the family-level non-enumerable `kind` on `SqlNode` and bounded
+ * to the minimum data the framework `Namespace` interface promises.
+ *
+ * **Freeze-trap warning.** The leaf constructor calls
+ * `freezeNode(this)` after installing `kind`. The leaf-class shape
+ * works today only because `NamespaceBase` does NOT freeze in its
+ * constructor — the `Object.defineProperty(this, 'kind', …)` call after
+ * `super()` succeeds because the instance is still mutable at that
+ * point. Subclasses that add instance fields will still hit the freeze
+ * trap once leaf-class `freezeNode(this)` runs; and if a future
+ * framework change lifts the freeze to `NamespaceBase`, even the
+ * `defineProperty` here would silently fail. To add subclass instance
+ * fields safely, lift `freezeNode` to a leaf-class `seal()` hook each
+ * leaf calls explicitly at the end of its own constructor.
+ */
+declare class SqlUnspecifiedNamespace extends NamespaceBase {
+  static readonly instance: SqlUnspecifiedNamespace;
+  readonly id: "__unspecified__";
+  readonly kind?: string;
+  private constructor();
+}
+//#endregion
+//#region src/types.d.ts
+type ForeignKeyOptions = {
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+};
+type SqlModelFieldStorage = {
+  readonly column: string;
+  readonly codecId?: string;
+  readonly nullable?: boolean;
+};
+type SqlModelStorage = {
+  readonly table: string;
+  readonly fields: Record<string, SqlModelFieldStorage>;
+};
+declare const DEFAULT_FK_CONSTRAINT = true;
+declare const DEFAULT_FK_INDEX = true;
+declare function applyFkDefaults(fk: {
+  constraint?: boolean | undefined;
+  index?: boolean | undefined;
+}, overrideDefaults?: {
+  constraint?: boolean | undefined;
+  index?: boolean | undefined;
+}): {
+  constraint: boolean;
+  index: boolean;
+};
+type TypeMaps<TCodecTypes extends Record<string, {
+  output: unknown;
+}> = Record<string, never>, TQueryOperationTypes extends Record<string, unknown> = Record<string, never>, TFieldOutputTypes extends Record<string, Record<string, unknown>> = Record<string, never>, TFieldInputTypes extends Record<string, Record<string, unknown>> = Record<string, never>> = {
+  readonly codecTypes: TCodecTypes;
+  readonly queryOperationTypes: TQueryOperationTypes;
+  readonly fieldOutputTypes: TFieldOutputTypes;
+  readonly fieldInputTypes: TFieldInputTypes;
+};
+type CodecTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly codecTypes: infer C;
+} ? C extends Record<string, {
+  output: unknown;
+}> ? C : Record<string, never> : Record<string, never>;
+/**
+ * Dispatch hint identifying the first-argument target of an operation.
+ *
+ * Used by ORM column helpers to decide whether an operation is reachable on a
+ * field. Either names a concrete codec identity or a set of capability traits
+ * that the field's codec must carry.
+ */
+type QueryOperationSelfSpec = {
+  readonly codecId: string;
+  readonly traits?: never;
+} | {
+  readonly traits: readonly CodecTrait[];
+  readonly codecId?: never;
+};
+/**
+ * Structural shape an operation's impl must return: any value carrying a
+ * codec-exact `returnType` descriptor. `Expression<T>` (from
+ * `@prisma-next/sql-relational-core/expression`, with `T extends ScopeField`)
+ * extends this. Trait-targeted returns are deliberately excluded — predicate
+ * detection and result decoding both depend on knowing the concrete return
+ * codec.
+ */
+type QueryOperationReturn = {
+  readonly returnType: {
+    readonly codecId: string;
+    readonly nullable: boolean;
+  };
+};
+type QueryOperationTypeEntry = {
+  readonly self?: QueryOperationSelfSpec;
+  readonly impl: (...args: never[]) => QueryOperationReturn;
+};
+type SqlQueryOperationTypes<_CT extends Record<string, {
+  readonly input: unknown;
+  readonly output: unknown;
+}>, T extends Record<string, QueryOperationTypeEntry>> = T;
+type QueryOperationTypesBase = Record<string, QueryOperationTypeEntry>;
+type QueryOperationTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly queryOperationTypes: infer Q;
+} ? Q extends Record<string, unknown> ? Q : Record<string, never> : Record<string, never>;
+type TypeMapsPhantomKey = '__@prisma-next/sql-contract/typeMaps@__';
+type ContractWithTypeMaps<TContract, TTypeMaps> = TContract & { readonly [K in TypeMapsPhantomKey]?: TTypeMaps };
+type ExtractTypeMapsFromContract<T> = TypeMapsPhantomKey extends keyof T ? NonNullable<T[TypeMapsPhantomKey & keyof T]> : never;
+type FieldOutputTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly fieldOutputTypes: infer F;
+} ? F extends Record<string, Record<string, unknown>> ? F : Record<string, never> : Record<string, never>;
+type FieldInputTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly fieldInputTypes: infer F;
+} ? F extends Record<string, Record<string, unknown>> ? F : Record<string, never> : Record<string, never>;
+type ExtractCodecTypes<T> = CodecTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractQueryOperationTypes<T> = QueryOperationTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractFieldOutputTypes<T> = FieldOutputTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractFieldInputTypes<T> = FieldInputTypesOf<ExtractTypeMapsFromContract<T>>;
+type ResolveCodecTypes<TContract, TTypeMaps> = [TTypeMaps] extends [never] ? ExtractCodecTypes<TContract> : CodecTypesOf<TTypeMaps>;
+//#endregion
+export { StorageTypeInstance as A, Index as B, TypeMapsPhantomKey as C, SqlStorageInput as D, SqlStorage as E, StorageTableInput as F, PostgresEnumStorageEntry as G, PrimaryKey as H, UniqueConstraint as I, ForeignKeyInput as J, isPostgresEnumStorageEntry as K, UniqueConstraintInput as L, isStorageTypeInstance as M, toStorageTypeInstance as N, SqlStorageTypeEntry as O, StorageTable as P, SqlNode as Q, StorageColumn as R, TypeMaps as S, SqlUnspecifiedNamespace as T, PrimaryKeyInput as U, IndexInput as V, POSTGRES_ENUM_KIND as W, ForeignKeyReferences as X, ReferentialAction as Y, ForeignKeyReferencesInput as Z, QueryOperationTypesOf as _, ExtractCodecTypes as a, SqlModelStorage as b, ExtractQueryOperationTypes as c, FieldOutputTypesOf as d, ForeignKeyOptions as f, QueryOperationTypesBase as g, QueryOperationTypeEntry as h, DEFAULT_FK_INDEX as i, StorageTypeInstanceInput as j, CODEC_INSTANCE_KIND as k, ExtractTypeMapsFromContract as l, QueryOperationSelfSpec as m, ContractWithTypeMaps as n, ExtractFieldInputTypes as o, QueryOperationReturn as p, ForeignKey as q, DEFAULT_FK_CONSTRAINT as r, ExtractFieldOutputTypes as s, CodecTypesOf as t, FieldInputTypesOf as u, ResolveCodecTypes as v, applyFkDefaults as w, SqlQueryOperationTypes as x, SqlModelFieldStorage as y, StorageColumnInput as z };
+//# sourceMappingURL=types-B0lbr9cb.d.mts.map

package/dist/types-B0lbr9cb.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-B0lbr9cb.d.mts","names":[],"sources":["../src/ir/sql-node.ts","../src/ir/foreign-key-references.ts","../src/ir/foreign-key.ts","../src/ir/postgres-enum-storage-entry.ts","../src/ir/primary-key.ts","../src/ir/sql-index.ts","../src/ir/storage-column.ts","../src/ir/unique-constraint.ts","../src/ir/storage-table.ts","../src/ir/storage-type-instance.ts","../src/ir/sql-storage.ts","../src/ir/sql-unspecified-namespace.ts","../src/types.ts"],"mappings":"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"}