@prisma/orm-postgres 0.16.0-dev.36

package/dist/contract-builder.d.mts

@@ -0,0 +1,521 @@
+import { PG_ENUM_CODEC_ID } from "@prisma/orm-target-postgres/target/codec-ids";
+import postgresPackRef from "@prisma/orm-target-postgres/target/pack";
+import { PostgresNativeEnum, RlsPolicyOperation } from "@prisma/orm-target-postgres/target/types";
+import { ComposedAuthoringHelpers, ComposedAuthoringHelpers as ComposedAuthoringHelpers$1, ContractDefinition, ContractInput, ContractInput as ContractInput$1, ContractModelBuilder, EnumMember, EnumTypeHandle, EnumTypeHandle as EnumTypeHandle$1, FieldNode, ForeignKeyNode, IndexNode, MergeEnums, ModelLike, ModelNode, PrimaryKeyNode, RelationNode, ScalarFieldBuilder, ScalarFieldBuilder as ScalarFieldBuilder$1, UniqueConstraintNode, buildBoundContract, buildSqlContractFromDefinition, field, member, model, rel } from "@prisma/orm-family-sql/contract-ts/contract-builder";
+import sqlFamilyPack from "@prisma/orm-family-sql/family/pack";
+import "@prisma/orm-framework/components/authoring";
+import { ColumnTypeDescriptor } from "@prisma/orm-framework/components/codec";
+import { ExtensionPackRef } from "@prisma/orm-framework/components/components";
+import { SqlNamespaceBase, SqlNamespaceInput, StorageTypeInstance } from "@prisma/orm-family-sql/contract/types";
+//#region ../../../3-extensions/postgres/dist/contract-builder.d.mts
+//#region src/contract/rls.d.ts
+/**
+ * Structural shape of the model handles the RLS helpers accept: any named
+ * `model(...)` builder from the contract DSL, including cross-space
+ * `extensionModel` handles. Helpers capture the handle by reference; nothing
+ * is read from it until `defineContract` lowers the entities list.
+ */
+interface RlsTargetModel {
+  readonly stageOne: {
+    readonly modelName?: string;
+    readonly namespace?: string;
+    readonly fields: Record<string, ScalarFieldBuilder$1>;
+  };
+}
+/**
+ * Role handle produced by {@link role}. Usable as a reference in a policy's
+ * `roles` list and as a declaration in the `entities` list (which lowers it
+ * to a `PostgresRole` entity).
+ */
+interface RlsRoleHandle<Name extends string = string> {
+  readonly entityKind: 'role';
+  readonly name: Name;
+}
+/** Enablement handle produced by {@link rlsEnabled}. */
+interface RlsEnablementHandle {
+  readonly entityKind: 'rls';
+  /** Declared model refs, resolved to table coordinates by the generic contract build. */
+  readonly refs: {
+    readonly target: RlsTargetModel;
+  };
+}
+/**
+ * Policy handle produced by the five `policy*` helpers. An inert value
+ * capturing the authoring inputs; wire-name hashing and table-name resolution
+ * happen when the handle is lowered by `defineContract`.
+ */
+interface RlsPolicyHandle<Operation extends RlsPolicyOperation = RlsPolicyOperation> {
+  readonly entityKind: 'policy';
+  readonly operation: Operation;
+  /** The policy name prefix (PSL's block name); the wire name appends a content hash. */
+  readonly name: string;
+  /** Declared model refs, resolved to table coordinates by the generic contract build. */
+  readonly refs: {
+    readonly target: RlsTargetModel;
+  };
+  readonly roles: readonly RlsRoleHandle[];
+  readonly using?: string;
+  readonly withCheck?: string;
+}
+/**
+ * The handle vocabulary `defineContract({ entities })` accepts: policies,
+ * role declarations, and RLS enablement markers.
+ */
+type RlsEntityHandle = RlsPolicyHandle | RlsRoleHandle | RlsEnablementHandle;
+interface RlsPolicyDescriptorBase {
+  /** The policy name prefix (PSL's block name); the wire name appends a content hash. */
+  readonly name: string;
+  readonly roles: readonly RlsRoleHandle[];
+}
+/** Descriptor for the USING-only operations: SELECT and DELETE. */
+interface RlsUsingPolicyDescriptor extends RlsPolicyDescriptorBase {
+  readonly using: string;
+}
+/** Descriptor for the WITH CHECK-only operation: INSERT. */
+interface RlsWithCheckPolicyDescriptor extends RlsPolicyDescriptorBase {
+  readonly withCheck: string;
+}
+/**
+ * Descriptor for the operations taking both predicates: UPDATE and ALL. At
+ * least one of `using`/`withCheck` is required; zero predicates is a compile
+ * error. Both stay individually optional because PSL's lowering accepts
+ * either alone, and the handle carries only what was authored — an omitted
+ * predicate is omitted from the content hash, byte-identical to PSL.
+ */
+type RlsUsingWithCheckPolicyDescriptor = (RlsPolicyDescriptorBase & {
+  readonly using: string;
+  readonly withCheck?: string;
+}) | (RlsPolicyDescriptorBase & {
+  readonly using?: string;
+  readonly withCheck: string;
+});
+/**
+ * Declares a Postgres role by name, mirroring PSL's bare role identifiers.
+ * Returns an inert handle: referenced in a policy's `roles` it contributes
+ * the bare name; placed in the `entities` list it declares the role
+ * (`entries.role`), making it subject to the existence verify.
+ */
+declare function role<const Name extends string>(name: Name): RlsRoleHandle<Name>;
+/**
+ * Marks a model's table RLS-controlled, mirroring PSL's `@@rls`. The
+ * enablement marker (never the policy set) drives `ENABLE`/`DISABLE ROW
+ * LEVEL SECURITY` planning.
+ */
+declare function rlsEnabled(model: RlsTargetModel): RlsEnablementHandle;
+/** Authors a `FOR SELECT` policy (PSL `policy_select`): row visibility via `using`. */
+declare function policySelect(model: RlsTargetModel, descriptor: RlsUsingPolicyDescriptor): RlsPolicyHandle<'select'>;
+/** Authors a `FOR INSERT` policy (PSL `policy_insert`): new-row validation via `withCheck`. */
+declare function policyInsert(model: RlsTargetModel, descriptor: RlsWithCheckPolicyDescriptor): RlsPolicyHandle<'insert'>;
+/** Authors a `FOR UPDATE` policy (PSL `policy_update`): takes `using` and `withCheck`. */
+declare function policyUpdate(model: RlsTargetModel, descriptor: RlsUsingWithCheckPolicyDescriptor): RlsPolicyHandle<'update'>;
+/** Authors a `FOR DELETE` policy (PSL `policy_delete`): row eligibility via `using`. */
+declare function policyDelete(model: RlsTargetModel, descriptor: RlsUsingPolicyDescriptor): RlsPolicyHandle<'delete'>;
+/** Authors a `FOR ALL` policy (PSL `policy_all`): takes `using` and `withCheck`. */
+declare function policyAll(model: RlsTargetModel, descriptor: RlsUsingWithCheckPolicyDescriptor): RlsPolicyHandle<'all'>;
+//#endregion
+//#region src/contract/define-contract.d.ts
+type SqlFamily = typeof sqlFamilyPack;
+type PostgresPack = typeof postgresPackRef;
+type TypesConstraint = Record<string, StorageTypeInstance>;
+type ModelsConstraint = Record<string, ModelLike>;
+type EnumsConstraint = Record<string, EnumTypeHandle$1>;
+type PostgresResult<Types extends TypesConstraint, Models extends ModelsConstraint, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Enums extends EnumsConstraint> = ReturnType<typeof buildBoundContract<SqlFamily, PostgresPack, {
+  readonly types?: Types;
+  readonly models?: Models;
+  readonly extensions?: Extensions;
+  readonly enums?: Enums;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
+}>>;
+type PostgresBaseScaffold<Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined> = Omit<ContractInput$1<SqlFamily, PostgresPack, Record<never, never>, Record<never, never>, Extensions>, 'family' | 'target' | 'types' | 'models' | 'enums' | 'createNamespace' | 'entities'> & {
+  /**
+   * RLS handles (`policy*`, `rlsEnabled`, `role`), lowered by the generic
+   * contract build through the postgres pack's entity-handle hook —
+   * mirroring the PSL `policy_*` / `@@rls` lowering key-for-key and
+   * wire-name-for-wire-name. This wrapper only narrows the element type;
+   * it contains no entity-kind logic.
+   */
+  readonly entities?: readonly RlsEntityHandle[];
+};
+type PostgresDefinition<Types extends TypesConstraint, Models extends ModelsConstraint, Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Enums extends EnumsConstraint> = PostgresBaseScaffold<Extensions> & {
+  readonly types?: Types;
+  readonly models?: Models;
+  readonly enums?: Enums;
+};
+type PostgresScaffold<Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined, Enums extends EnumsConstraint> = PostgresBaseScaffold<Extensions> & {
+  readonly types?: never;
+  readonly models?: never;
+  readonly enums?: Enums;
+};
+declare function defineContract<const Types extends TypesConstraint = Record<never, never>, const Models extends ModelsConstraint = Record<never, never>, const Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, const Enums extends EnumsConstraint = Record<never, never>>(definition: PostgresDefinition<Types, Models, Extensions, Enums>): PostgresResult<Types, Models, Extensions, Enums>;
+declare function defineContract<const Types extends TypesConstraint = Record<never, never>, const Models extends ModelsConstraint = Record<never, never>, const Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined, const ScaffoldEnums extends EnumsConstraint = Record<never, never>, const FactoryEnums extends EnumsConstraint = Record<never, never>>(scaffold: PostgresScaffold<Extensions, ScaffoldEnums>, factory: (helpers: ComposedAuthoringHelpers$1<SqlFamily, PostgresPack, Extensions>) => {
+  readonly types?: Types;
+  readonly models?: Models;
+  readonly enums?: FactoryEnums;
+}): PostgresResult<Types, Models, Extensions, MergeEnums<ScaffoldEnums, FactoryEnums>>;
+//#endregion
+//#region ../../1-framework/2-authoring/contract/dist/index.d.mts
+//#endregion
+//#region src/enum-type.d.ts
+/**
+ * A single enum member produced by `member()`. The `Name` and `Value` generics
+ * are preserved as literal types so `enumType()` can carry the ordered value
+ * tuple in its return type. `Value` is whatever the codec dictates — its type
+ * is constrained at `enumType` against the codec's input type, not here.
+ */
+interface EnumMember$1<Name extends string, Value> {
+  readonly name: Name;
+  readonly value: Value;
+}
+type MembersToValues<Members extends readonly EnumMember$1<string, unknown>[]> = { readonly [K in keyof Members]: Members[K] extends EnumMember$1<string, infer V> ? V : never; };
+type MembersToNames<Members extends readonly EnumMember$1<string, unknown>[]> = { readonly [K in keyof Members]: Members[K] extends EnumMember$1<infer N, unknown> ? N : never; };
+type MembersAccessorMap<Members extends readonly EnumMember$1<string, unknown>[]> = { readonly [M in Members[number] as M['name']]: M['value']; };
+declare const ENUM_TYPE_HANDLE_BRAND = "__prismaNextEnumTypeHandle__";
+/** Authoring handle returned by `enumType()`. Generic over the ordered value tuple so `const Role = enumType(...)` retains literal types. */
+interface EnumTypeHandle$2<Name extends string = string, Values extends readonly unknown[] = readonly unknown[], Names extends readonly string[] = readonly string[], MembersMap extends Record<string, unknown> = Record<string, unknown>> {
+  /** Internal brand for lowering-pipeline detection. */
+  readonly [ENUM_TYPE_HANDLE_BRAND]: true;
+  /** The enum's declared name (used as the key in domain `enum` / storage `valueSet`). */
+  readonly enumName: Name;
+  /** codecId from the codec passed to `enumType`. */
+  readonly codecId: string;
+  /** nativeType from the codec passed to `enumType`. */
+  readonly nativeType: string;
+  /** Ordered member list for lowering (name + value pairs). */
+  readonly enumMembers: readonly {
+    readonly name: string;
+    readonly value: Values[number];
+  }[];
+  /** Ordered literal value tuple. Declaration order is preserved. */
+  readonly values: Values;
+  /** Ordered literal name tuple. Declaration order is preserved. */
+  readonly names: Names;
+  /**
+   * Namespaced accessor map: `Role.members.User === 'user'`.
+   * Namespaced under `.members` to avoid collisions with `.values` / `.has`.
+   */
+  readonly members: MembersMap;
+  /** Returns `true` if `v` is a declared member value. */
+  has(v: Values[number]): boolean;
+  /** Returns the member name for a value, or `undefined` if not found. */
+  nameOf(v: Values[number]): string | undefined;
+  /** Returns the zero-based declaration index of a value, or `-1` if not found. */
+  ordinalOf(v: Values[number]): number;
+}
+/**
+ * A codec typemap: codecId → `{ input, output }`, the same shape the query
+ * lanes consume. The bound `enumType` wrappers supply the target pack's
+ * typemap; the core defaults to an empty map (no codec is known), so member
+ * values stay unconstrained.
+ */
+type CodecTypeMap = Record<string, {
+  readonly input?: unknown;
+}>;
+/**
+ * The application input type the codec dictates for an enum's member values:
+ * looks `Codec['codecId']` up in the supplied codec typemap. When the codecId
+ * isn't in the map the input is unconstrained, so any member-value literal is
+ * accepted and inferred verbatim.
+ */
+type CodecInput<CodecTypes extends CodecTypeMap, Codec extends {
+  readonly codecId: string;
+}> = Codec['codecId'] extends keyof CodecTypes ? CodecTypes[Codec['codecId']] extends {
+  readonly input: infer In;
+} ? In : unknown : unknown;
+/**
+ * The signature of an `enumType` whose codec typemap is already bound — the
+ * shape a target-bound wrapper (e.g. `@internal/postgres/contract-builder`)
+ * exposes. The member values are constrained to the codec's input type drawn
+ * from `CodecTypes`, while `Name`, `Codec`, and the member tuple still infer
+ * from the call.
+ */
+type BoundEnumType<CodecTypes extends CodecTypeMap> = <const Name extends string, const Codec extends Pick<ColumnTypeDescriptor, 'codecId' | 'nativeType'>, const Members extends readonly [EnumMember$1<string, CodecInput<CodecTypes, Codec>>, ...EnumMember$1<string, CodecInput<CodecTypes, Codec>>[]]>(name: Name, codec: Codec, ...members: Members) => EnumTypeHandle$2<Name, MembersToValues<[...Members]>, MembersToNames<[...Members]>, MembersAccessorMap<[...Members]>>;
+//#endregion
+//#region src/contract/enum-type.d.ts
+/**
+ * The `enumType` authors call when building a Postgres contract (re-exported
+ * from `@internal/postgres/contract-builder`).
+ *
+ * `bindEnumType` is the core, codec-agnostic `enumType` factory; calling it with
+ * the Postgres pack's codec typemap fixes which member-value type each codec
+ * permits, so `member()` values are checked against the column's codec at
+ * authoring time: `pg/text@1` requires `string`, `pg/int4@1` requires `number`,
+ * and a mismatch is a compile error. The core `enumType` can't know the codec
+ * set, which is why the binding happens here, per target.
+ */
+declare const enumType: BoundEnumType<{
+  readonly "sql/char@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order" | "textual";
+  }, "traits" | "output" | "input">;
+  readonly "sql/varchar@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order" | "textual";
+  }, "traits" | "output" | "input">;
+  readonly "sql/int@1": Pick<{
+    readonly input: number;
+    readonly output: number;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "numeric" | "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "sql/float@1": Pick<{
+    readonly input: number;
+    readonly output: number;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "numeric" | "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "sql/text@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order" | "textual";
+  }, "traits" | "output" | "input">;
+  readonly "sql/timestamp@1": Pick<{
+    readonly input: Date;
+    readonly output: Date;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/text@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order" | "textual";
+  }, "traits" | "output" | "input">;
+  readonly "pg/enum@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order" | "textual";
+  }, "traits" | "output" | "input">;
+  readonly "pg/char@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order" | "textual";
+  }, "traits" | "output" | "input">;
+  readonly "pg/varchar@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order" | "textual";
+  }, "traits" | "output" | "input">;
+  readonly "pg/int@1": Pick<{
+    readonly input: number;
+    readonly output: number;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "numeric" | "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/float@1": Pick<{
+    readonly input: number;
+    readonly output: number;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "numeric" | "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/int4@1": Pick<{
+    readonly input: number;
+    readonly output: number;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "numeric" | "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/int2@1": Pick<{
+    readonly input: number;
+    readonly output: number;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "numeric" | "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/int8@1": Pick<{
+    readonly input: bigint;
+    readonly output: bigint;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "numeric" | "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/float4@1": Pick<{
+    readonly input: number;
+    readonly output: number;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "numeric" | "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/float8@1": Pick<{
+    readonly input: number;
+    readonly output: number;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "numeric" | "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/numeric@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "numeric" | "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/date@1": Pick<{
+    readonly input: Date;
+    readonly output: Date;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/timestamp@1": Pick<{
+    readonly input: Date;
+    readonly output: Date;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/timestamptz@1": Pick<{
+    readonly input: Date;
+    readonly output: Date;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/time@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/timetz@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/bool@1": Pick<{
+    readonly input: boolean;
+    readonly output: boolean;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "boolean" | "equality";
+  }, "traits" | "output" | "input">;
+  readonly "pg/bit@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/varbit@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/bytea@1": Pick<{
+    readonly input: Uint8Array<ArrayBufferLike>;
+    readonly output: Uint8Array<ArrayBufferLike>;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality";
+  }, "traits" | "output" | "input">;
+  readonly "pg/uuid@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/inet@1": Pick<{
+    readonly input: string;
+    readonly output: string;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/interval@1": Pick<{
+    readonly input: import("@prisma/orm-target-postgres/target/codecs").PgInterval;
+    readonly output: import("@prisma/orm-target-postgres/target/codecs").PgInterval;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality" | "order";
+  }, "traits" | "output" | "input">;
+  readonly "pg/json@1": Pick<{
+    readonly input: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly output: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: never;
+  }, "traits" | "output" | "input">;
+  readonly "pg/jsonb@1": Pick<{
+    readonly input: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly output: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly json: import("@prisma/orm-framework/contract/types").JsonValue;
+    readonly traits: "equality";
+  }, "traits" | "output" | "input">;
+}>;
+//#endregion
+//#region src/contract/native-enum.d.ts
+/**
+ * Handle returned by {@link nativeEnum}. Mirrors PSL's two distinct strings for
+ * a `native_enum <Name> { … @@map("type_name") }` block:
+ *
+ * - `name` — the entity name: the key in `entries.native_enum` /
+ *   `entries.valueSet`, and the column's `valueSet` ref `entityName`.
+ * - `typeName` — the Postgres type name (`CREATE TYPE <typeName> AS ENUM (…)`
+ *   and the `$N::<typeName>` cast). Defaults to `name`; override with
+ *   {@link NativeEnumHandle.map}.
+ */
+interface NativeEnumHandle<Name extends string = string, TypeName extends string = string, Members extends readonly [string, ...string[]] = readonly [string, ...string[]]> {
+  readonly entityKind: 'native_enum';
+  readonly name: Name;
+  readonly typeName: TypeName;
+  readonly members: Members;
+  readonly entity: PostgresNativeEnum<Members>;
+  /**
+   * Overrides the Postgres type name (PSL's `@@map("type_name")`), keeping the
+   * entity `name` unchanged. `nativeEnum('AalLevel', …).map('aal_level')` →
+   * entity name `AalLevel`, Postgres type `aal_level`.
+   */
+  map<const MappedTypeName extends string>(typeName: MappedTypeName): NativeEnumHandle<Name, MappedTypeName, Members>;
+}
+/**
+ * Declares a native Postgres enum type for use with {@link pg}'s `.enum()`
+ * column helper. Mirrors PSL's `native_enum <Name> { … }` lowering
+ * (`lowerNativeEnumFromBlock`): validates a non-empty, duplicate-free member
+ * list and builds the same {@link PostgresNativeEnum} entity. Its value-set is
+ * derived generically at contract-build time — the same
+ * `deriveValueSetFromEntity` fold PSL's native enums go through — once
+ * `pg.enum(handle)` lands the entity in the field's owning namespace.
+ *
+ * The first argument is the entity `name` (the `entries.native_enum` /
+ * `entries.valueSet` key). The Postgres type name defaults to `name`; use
+ * `.map(typeName)` to override it (PSL's `@@map`).
+ *
+ * A handle referenced by columns in N different namespaces materialises N
+ * native enum types (one per namespace) — by design: a Postgres type lives in
+ * exactly one schema, and PSL can't share a type across schemas either.
+ *
+ * @example
+ * ```ts
+ * // name === Postgres type name
+ * const Role = nativeEnum('Role', 'user', 'admin');
+ * // entity name `AalLevel`, Postgres type `aal_level` (Supabase's auth.aal_level)
+ * const AalLevel = nativeEnum('AalLevel', 'aal1', 'aal2', 'aal3').map('aal_level');
+ * model('Session', { fields: { aal: field.column(pg.enum(AalLevel)).optional() } });
+ * ```
+ */
+declare function nativeEnum<const Name extends string, const Members extends readonly [string, ...string[]]>(name: Name, ...members: Members): NativeEnumHandle<Name, Name, Members>;
+/**
+ * The descriptor `pg.enum(handle)` returns: an `entityRef.entity` typed to the
+ * handle's own `PostgresNativeEnum<Members>`, so the member-value literal
+ * tuple survives on the descriptor type instead of widening to `unknown`.
+ */
+type PgEnumColumnDescriptor<Members extends readonly [string, ...string[]]> = ColumnTypeDescriptor<typeof PG_ENUM_CODEC_ID> & {
+  readonly entityRef: {
+    readonly entityKind: 'native_enum';
+    readonly entityName: string;
+    readonly entity: PostgresNativeEnum<Members>;
+  };
+};
+/**
+ * Builds the deferred column descriptor for `handle`: the bare Postgres type
+ * name and `typeParams` come from `pgEnumDescriptor.columnFromEntity` (the same
+ * authoring hook the PSL `pg.enum(Ref)` type constructor resolves through),
+ * carrying `handle.entity` as the descriptor's `entityRef` keyed by the entity
+ * `name` (not the Postgres type name — they differ when `.map()` was used).
+ * Schema qualification and the storage `valueSet` ref are NOT computed here — a
+ * `field.column(pg.enum(handle))` call runs before the enclosing `model(...)`
+ * associates a namespace, so `buildSqlContractFromDefinition` resolves both
+ * once the field's namespace is known.
+ */
+declare function pgEnumColumn<const Name extends string, const TypeName extends string, const Members extends readonly [string, ...string[]]>(handle: NativeEnumHandle<Name, TypeName, Members>): PgEnumColumnDescriptor<Members>;
+/** Postgres-specific TS type-constructor namespace, mirroring the PSL `pg.` prefix. */
+declare const pg: {
+  readonly enum: typeof pgEnumColumn;
+};
+//#endregion
+export { type ComposedAuthoringHelpers, type ContractDefinition, type ContractInput, type ContractModelBuilder, type EnumMember, type EnumTypeHandle, type FieldNode, type ForeignKeyNode, type IndexNode, type ModelNode, type NativeEnumHandle, type PrimaryKeyNode, type RelationNode, type RlsEnablementHandle, type RlsEntityHandle, type RlsPolicyHandle, type RlsRoleHandle, type RlsTargetModel, type RlsUsingPolicyDescriptor, type RlsUsingWithCheckPolicyDescriptor, type RlsWithCheckPolicyDescriptor, type ScalarFieldBuilder, type UniqueConstraintNode, buildSqlContractFromDefinition, defineContract, enumType, field, member, model, nativeEnum, pg, policyAll, policyDelete, policyInsert, policySelect, policyUpdate, rel, rlsEnabled, role };
+//# sourceMappingURL=contract-builder.d.mts.map

package/dist/contract-builder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-builder.d.mts","names":[],"sources":["../../../../3-extensions/postgres/dist/contract-builder.d.mts"],"mappings":"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"}