@prisma/orm-target-postgres 0.16.0-dev.36

package/dist/codecs-Cvqvb9pV-Cdc51FKY.d.mts

@@ -0,0 +1,589 @@
+import { r as PostgresCodecDescriptor } from "./codec-descriptor-Bec_zukr-BfvtUqhm.mjs";
+import { C as PG_TIMETZ_CODEC_ID, E as PG_VARBIT_CODEC_ID, S as PG_TIMESTAMP_CODEC_ID, T as PG_UUID_CODEC_ID, _ as PG_JSON_CODEC_ID, a as PG_DATE_CODEC_ID, b as PG_TEXT_CODEC_ID, c as PG_FLOAT8_CODEC_ID, d as PG_INT2_CODEC_ID, f as PG_INT4_CODEC_ID, g as PG_JSONB_CODEC_ID, m as PG_INTERVAL_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_ENUM_CODEC_ID, p as PG_INT8_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_FLOAT4_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INET_CODEC_ID, v as PG_NUMERIC_CODEC_ID, w as PG_TIME_CODEC_ID, x as PG_TIMESTAMPTZ_CODEC_ID } from "./codec-ids-CsOU3xDv-mPI0INiF.mjs";
+import { ProjectionExpr, SqlCharCodec, SqlFloatCodec, SqlIntCodec, SqlVarcharCodec } from "@prisma/orm-family-sql/relational-core/ast";
+import { CodecCallContext, CodecImpl, CodecInstanceContext } from "@prisma/orm-framework/components/codec";
+import { JsonValue } from "@prisma/orm-framework/contract/types";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region ../../../3-targets/3-targets/postgres/dist/codecs-Cvqvb9pV.d.mts
+//#region src/core/codec-helpers.d.ts
+/**
+ * The application value of a `pg/interval@1` column.
+ *
+ * A PostgreSQL interval is three independent fields — months, days and
+ * microseconds — not a single duration. `1 month` and `30 days` are different
+ * intervals because a month has no fixed length, so the three fields are carried
+ * separately and never collapsed into one another. Reading a value is therefore
+ * reading these three numbers, not parsing a string.
+ *
+ * `months` and `days` are `number` because PostgreSQL stores each as a 32-bit
+ * integer, which a JS number holds exactly. `micros` is `bigint` because
+ * PostgreSQL stores it as a 64-bit integer, whose range a JS number does not
+ * cover — the same reason `pg/int8@1` carries `bigint`.
+ *
+ * The canonical JSON of this codec is the ISO-8601 duration string, not this
+ * object: the value and its representation are independent, as they are for
+ * `pg/bytea@1` (`Uint8Array` / base64) and `pg/int8@1` (`bigint` / decimal text).
+ */
+interface PgInterval {
+  readonly months: number;
+  readonly days: number;
+  readonly micros: bigint;
+}
+//#endregion
+//#region src/core/codecs.d.ts
+type LengthParams = {
+  readonly length?: number;
+};
+type PrecisionParams = {
+  readonly precision?: number;
+};
+type NumericParams = {
+  readonly precision?: number;
+  readonly scale?: number;
+};
+declare class PgTextCodec extends CodecImpl<typeof PG_TEXT_CODEC_ID, readonly ['equality', 'order', 'textual'], string, string> {
+  encode(value: string, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class PgTextDescriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/text@1";
+  readonly traits: readonly ["equality", "order", "textual"];
+  readonly targetTypes: readonly ["text"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(): (ctx: CodecInstanceContext) => PgTextCodec;
+}
+declare const pgTextColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgTextCodec, undefined>;
+/**
+ * Codec for a `pg.enum(Ref)` column bound to a native Postgres enum type.
+ * Text passthrough, identical to `pg/text@1` — encode/decode do not carry the
+ * enum's member values; membership is enforced by the native type itself, not
+ * by this codec. `renderValueLiteral` renders a member value as its TS
+ * literal, which is what drives the column's typed value-union (via
+ * `renderValueSetType` reading the column's `valueSet` ref) — the codec
+ * itself carries no params of its own; typing comes entirely from the
+ * column's value-set, not from `pg/enum@1`.
+ *
+ * A distinct codec id (rather than reusing `pg/text@1` on a plain text
+ * column) keeps native-enum columns independently identifiable — from a
+ * column's `codecId` alone, without also inspecting `nativeType` — which
+ * the managed (DDL) phase needs to target `CREATE TYPE`/`ALTER TYPE`
+ * operations at exactly the columns that use one.
+ */
+declare class PgEnumCodec extends CodecImpl<typeof PG_ENUM_CODEC_ID, readonly ['equality', 'order', 'textual'], string, string> {
+  encode(value: string, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+type PgEnumParams = {
+  readonly typeName: string;
+};
+/**
+ * Narrows codec `typeParams` to {@link PgEnumParams} — the shape that binds a
+ * column to a named database type (a native enum's `CREATE TYPE` name).
+ */
+declare function isPgEnumParams(value: unknown): value is PgEnumParams;
+declare class PgEnumDescriptor extends PostgresCodecDescriptor<PgEnumParams> {
+  protected nativeType(params: PgEnumParams): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/enum@1";
+  readonly traits: readonly ["equality", "order", "textual"];
+  readonly targetTypes: readonly ["text"];
+  readonly paramsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    typeName: string;
+  }, {}>;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(_params: PgEnumParams): (ctx: CodecInstanceContext) => PgEnumCodec;
+  /**
+   * Authoring-time hook a `pg.enum(<ref>)` type constructor calls once it has
+   * resolved its ref argument to the referenced `native_enum` entity:
+   * produces this codec's per-column `typeParams` and native type from the
+   * entity's bare type name. Schema-qualification (`auth.aal_level` for a
+   * named non-default schema) is not this hook's concern — the field's
+   * namespace isn't known at this call site for every authoring path (the TS
+   * builder resolves a column before it knows its model's namespace), so it is
+   * applied later, at contract construction, by {@link qualifyNativeType} via
+   * the target's `authoring.qualifyColumnType` hook. `nativeType` mirrors
+   * `typeParams.typeName` — the same value `nativeTypeFor` derives at render
+   * time — so the column's declared native type and the render-time cast
+   * agree. Returns `undefined` if `entity` is not a `PostgresNativeEnum` (a
+   * contributor bug, not a user-schema error — the caller decides how to
+   * report it).
+   */
+  columnFromEntity(entity: object): {
+    readonly typeParams: PgEnumParams;
+    readonly nativeType: string;
+  } | undefined;
+  /**
+   * Schema-qualifies this native enum type's name for the namespace the
+   * consuming column lives in: `${namespaceId}.${typeName}` for a named
+   * non-default schema, bare for the target's default schema (`public`) or
+   * the late-bound unbound sentinel (whose schema `search_path` resolves at
+   * runtime). Postgres's `format_type()` reports the bare name for a
+   * public-schema type, so a public column's declared native type must stay
+   * bare to match. Owned here because the codec owns its native type.
+   */
+  qualifyNativeType(typeName: string, namespaceId: string): string;
+}
+declare const pgEnumDescriptor: PgEnumDescriptor;
+/**
+ * Contract-construction-time column-type qualifier the Postgres target
+ * contributes through `authoring.qualifyColumnType`.
+ * `buildSqlContractFromDefinition` calls this for every column as it is
+ * constructed, passing the column's bare type info and its owning
+ * `namespaceId`; a native-enum column (`pg/enum@1`) gets its type name
+ * schema-qualified for that namespace (via
+ * {@link PgEnumDescriptor.qualifyNativeType}), keeping `nativeType` and
+ * `typeParams.typeName` in sync. Every other codec passes through unchanged.
+ * Both the PSL `pg.enum(Ref)` path and the TS `pg.enum(handle)` path route
+ * through here — the dispatch keys off the codec id, not authoring surface.
+ */
+declare function postgresQualifyColumnType(input: {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams?: Record<string, unknown>;
+}, namespaceId: string): {
+  readonly nativeType: string;
+  readonly typeParams?: Record<string, unknown>;
+};
+declare class PgInt4Codec extends CodecImpl<typeof PG_INT4_CODEC_ID, readonly ['equality', 'order', 'numeric'], number, number> {
+  encode(value: number, _ctx: CodecCallContext): Promise<number>;
+  decode(wire: number, _ctx: CodecCallContext): Promise<number>;
+  encodeJson(value: number): JsonValue;
+  decodeJson(json: JsonValue): number;
+}
+declare class PgInt4Descriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/int4@1";
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly targetTypes: readonly ["int4"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(): (ctx: CodecInstanceContext) => PgInt4Codec;
+}
+declare const pgInt4Column: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgInt4Codec, undefined>;
+declare class PgInt2Codec extends CodecImpl<typeof PG_INT2_CODEC_ID, readonly ['equality', 'order', 'numeric'], number, number> {
+  encode(value: number, _ctx: CodecCallContext): Promise<number>;
+  decode(wire: number, _ctx: CodecCallContext): Promise<number>;
+  encodeJson(value: number): JsonValue;
+  decodeJson(json: JsonValue): number;
+}
+declare class PgInt2Descriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/int2@1";
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly targetTypes: readonly ["int2"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(): (ctx: CodecInstanceContext) => PgInt2Codec;
+}
+declare const pgInt2Column: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgInt2Codec, undefined>;
+/**
+ * A Postgres `int8` spans the full signed 64-bit range, which a JS `number`
+ * cannot hold past 2^53. Application values are `bigint` and the canonical JSON
+ * is decimal text; the wire form is the decimal string `pg` reads and writes for
+ * this type.
+ */
+declare class PgInt8Codec extends CodecImpl<typeof PG_INT8_CODEC_ID, readonly ['equality', 'order', 'numeric'], string | number | bigint, bigint> {
+  encode(value: bigint, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string | number | bigint, _ctx: CodecCallContext): Promise<bigint>;
+  encodeJson(value: bigint): JsonValue;
+  decodeJson(json: JsonValue): bigint;
+}
+declare class PgInt8Descriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/int8@1";
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly targetTypes: readonly ["int8"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(): (ctx: CodecInstanceContext) => PgInt8Codec;
+}
+declare const pgInt8Column: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgInt8Codec, undefined>;
+declare class PgFloat4Codec extends CodecImpl<typeof PG_FLOAT4_CODEC_ID, readonly ['equality', 'order', 'numeric'], number, number> {
+  encode(value: number, _ctx: CodecCallContext): Promise<number>;
+  decode(wire: number, _ctx: CodecCallContext): Promise<number>;
+  encodeJson(value: number): JsonValue;
+  decodeJson(json: JsonValue): number;
+}
+declare class PgFloat4Descriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/float4@1";
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly targetTypes: readonly ["float4"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(): (ctx: CodecInstanceContext) => PgFloat4Codec;
+}
+declare const pgFloat4Column: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgFloat4Codec, undefined>;
+declare class PgFloat8Codec extends CodecImpl<typeof PG_FLOAT8_CODEC_ID, readonly ['equality', 'order', 'numeric'], number, number> {
+  encode(value: number, _ctx: CodecCallContext): Promise<number>;
+  decode(wire: number, _ctx: CodecCallContext): Promise<number>;
+  encodeJson(value: number): JsonValue;
+  decodeJson(json: JsonValue): number;
+}
+declare class PgFloat8Descriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/float8@1";
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly targetTypes: readonly ["float8"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(): (ctx: CodecInstanceContext) => PgFloat8Codec;
+}
+declare const pgFloat8Column: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgFloat8Codec, undefined>;
+declare class PgBoolCodec extends CodecImpl<typeof PG_BOOL_CODEC_ID, readonly ['equality', 'boolean'], boolean, boolean> {
+  encode(value: boolean, _ctx: CodecCallContext): Promise<boolean>;
+  decode(wire: boolean, _ctx: CodecCallContext): Promise<boolean>;
+  encodeJson(value: boolean): JsonValue;
+  decodeJson(json: JsonValue): boolean;
+}
+declare class PgBoolDescriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/bool@1";
+  readonly traits: readonly ["equality", "boolean"];
+  readonly targetTypes: readonly ["bool"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(): (ctx: CodecInstanceContext) => PgBoolCodec;
+}
+declare const pgBoolColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgBoolCodec, undefined>;
+declare class PgNumericCodec extends CodecImpl<typeof PG_NUMERIC_CODEC_ID, readonly ['equality', 'order', 'numeric'], string | number, string> {
+  encode(value: string, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string | number, _ctx: CodecCallContext): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class PgNumericDescriptor extends PostgresCodecDescriptor<NumericParams> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/numeric@1";
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly targetTypes: readonly ["numeric", "decimal"];
+  readonly paramsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    precision?: number;
+    scale?: number;
+  }, {}>;
+  renderOutputType(params: NumericParams): string | undefined;
+  factory(_params: NumericParams): (ctx: CodecInstanceContext) => PgNumericCodec;
+}
+declare const pgNumericColumn: (params?: NumericParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<PgNumericCodec, NumericParams>;
+/**
+ * A Postgres `date` has no time-of-day or timezone component. This codec
+ * canonicalizes its JS-level value as a `Date` at UTC midnight, so its
+ * round-trip is independent of the process's local timezone — see
+ * `pgDateEncode`/`pgDateDecode` in `codec-helpers.ts`.
+ */
+declare class PgDateCodec extends CodecImpl<typeof PG_DATE_CODEC_ID, readonly ['equality', 'order'], Date | string, Date> {
+  encode(value: Date, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: Date, _ctx: CodecCallContext): Promise<Date>;
+  encodeJson(value: Date): JsonValue;
+  decodeJson(json: JsonValue): Date;
+}
+declare class PgDateDescriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/date@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["date"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  factory(): (ctx: CodecInstanceContext) => PgDateCodec;
+}
+declare const pgDateColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgDateCodec, undefined>;
+declare class PgTimestampCodec extends CodecImpl<typeof PG_TIMESTAMP_CODEC_ID, readonly ['equality', 'order'], Date, Date> {
+  encode(value: Date, _ctx: CodecCallContext): Promise<Date>;
+  decode(wire: Date, _ctx: CodecCallContext): Promise<Date>;
+  encodeJson(value: Date): JsonValue;
+  decodeJson(json: JsonValue): Date;
+}
+declare class PgTimestampDescriptor extends PostgresCodecDescriptor<PrecisionParams> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/timestamp@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["timestamp"];
+  readonly paramsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    precision?: number;
+  }, {}>;
+  renderOutputType(params: PrecisionParams): string | undefined;
+  factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => PgTimestampCodec;
+}
+declare const pgTimestampColumn: (params?: PrecisionParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<PgTimestampCodec, PrecisionParams>;
+declare class PgTimestamptzCodec extends CodecImpl<typeof PG_TIMESTAMPTZ_CODEC_ID, readonly ['equality', 'order'], Date, Date> {
+  encode(value: Date, _ctx: CodecCallContext): Promise<Date>;
+  decode(wire: Date, _ctx: CodecCallContext): Promise<Date>;
+  encodeJson(value: Date): JsonValue;
+  decodeJson(json: JsonValue): Date;
+}
+declare class PgTimestamptzDescriptor extends PostgresCodecDescriptor<PrecisionParams> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/timestamptz@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["timestamptz"];
+  readonly paramsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    precision?: number;
+  }, {}>;
+  renderOutputType(params: PrecisionParams): string | undefined;
+  factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => PgTimestamptzCodec;
+}
+declare const pgTimestamptzColumn: (params?: PrecisionParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<PgTimestamptzCodec, PrecisionParams>;
+declare class PgTimeCodec extends CodecImpl<typeof PG_TIME_CODEC_ID, readonly ['equality', 'order'], string, string> {
+  encode(value: string, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class PgTimeDescriptor extends PostgresCodecDescriptor<PrecisionParams> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/time@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["time"];
+  readonly paramsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    precision?: number;
+  }, {}>;
+  renderOutputType(params: PrecisionParams): string | undefined;
+  factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => PgTimeCodec;
+}
+declare const pgTimeColumn: (params?: PrecisionParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<PgTimeCodec, PrecisionParams>;
+declare class PgTimetzCodec extends CodecImpl<typeof PG_TIMETZ_CODEC_ID, readonly ['equality', 'order'], string, string> {
+  encode(value: string, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class PgTimetzDescriptor extends PostgresCodecDescriptor<PrecisionParams> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/timetz@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["timetz"];
+  readonly paramsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    precision?: number;
+  }, {}>;
+  renderOutputType(params: PrecisionParams): string | undefined;
+  factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => PgTimetzCodec;
+}
+declare const pgTimetzColumn: (params?: PrecisionParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<PgTimetzCodec, PrecisionParams>;
+declare class PgBitCodec extends CodecImpl<typeof PG_BIT_CODEC_ID, readonly ['equality', 'order'], string, string> {
+  encode(value: string, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class PgBitDescriptor extends PostgresCodecDescriptor<LengthParams> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/bit@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["bit"];
+  readonly paramsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    length?: number;
+  }, {}>;
+  renderOutputType(params: LengthParams): string | undefined;
+  factory(_params: LengthParams): (ctx: CodecInstanceContext) => PgBitCodec;
+}
+declare const pgBitColumn: (params?: LengthParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<PgBitCodec, LengthParams>;
+declare class PgVarbitCodec extends CodecImpl<typeof PG_VARBIT_CODEC_ID, readonly ['equality', 'order'], string, string> {
+  encode(value: string, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class PgVarbitDescriptor extends PostgresCodecDescriptor<LengthParams> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/varbit@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["bit varying"];
+  readonly paramsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    length?: number;
+  }, {}>;
+  renderOutputType(params: LengthParams): string | undefined;
+  factory(_params: LengthParams): (ctx: CodecInstanceContext) => PgVarbitCodec;
+}
+declare const pgVarbitColumn: (params?: LengthParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<PgVarbitCodec, LengthParams>;
+declare class PgByteaCodec extends CodecImpl<typeof PG_BYTEA_CODEC_ID, readonly ['equality'], Uint8Array, Uint8Array> {
+  encode(value: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array>;
+  decode(wire: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array>;
+  encodeJson(value: Uint8Array): JsonValue;
+  decodeJson(json: JsonValue): Uint8Array;
+}
+declare class PgByteaDescriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/bytea@1";
+  readonly traits: readonly ["equality"];
+  readonly targetTypes: readonly ["bytea"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  factory(): (ctx: CodecInstanceContext) => PgByteaCodec;
+}
+declare class PgUuidCodec extends CodecImpl<typeof PG_UUID_CODEC_ID, readonly ['equality', 'order'], string, string> {
+  encode(value: string, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class PgUuidDescriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/uuid@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["uuid"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  factory(): (ctx: CodecInstanceContext) => PgUuidCodec;
+}
+declare const pgUuidColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgUuidCodec, undefined>;
+declare class PgInetCodec extends CodecImpl<typeof PG_INET_CODEC_ID, readonly ['equality', 'order'], string, string> {
+  encode(value: string, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class PgInetDescriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/inet@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["inet"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  factory(): (ctx: CodecInstanceContext) => PgInetCodec;
+}
+declare const pgInetColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgInetCodec, undefined>;
+/**
+ * An application value is a {@link PgInterval} — the three fields PostgreSQL
+ * actually stores, `{ months, days, micros }` — and its canonical JSON is the
+ * ISO-8601 duration string PostgreSQL spells under
+ * `IntervalStyle = 'iso_8601'`: `P1M`, `P30D`, `P1Y2M3DT4H5M6S`, `PT0S` for
+ * zero, each component carrying its own sign.
+ *
+ * Value and representation are independent here, as they are for `pg/bytea@1`
+ * (`Uint8Array` carried as base64) and `pg/int8@1` (`bigint` carried as decimal
+ * text). Reading an interval hands back numbers to compute with rather than a
+ * string to parse; writing one takes the same numbers.
+ *
+ * The fields stay independent because a month has no fixed length: `{months: 1}`
+ * and `{days: 30}` are different values and neither converts to the other. The
+ * ISO rendering normalises only in its own spelling — twelve months render as a
+ * year — so `{months: 13}` renders `P1Y1M` and reads back as `{months: 13}`.
+ */
+declare class PgIntervalCodec extends CodecImpl<typeof PG_INTERVAL_CODEC_ID, readonly ['equality', 'order'], string | Record<string, unknown>, PgInterval> {
+  encode(value: PgInterval, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string | Record<string, unknown>, _ctx: CodecCallContext): Promise<PgInterval>;
+  encodeJson(value: PgInterval): JsonValue;
+  decodeJson(json: JsonValue): PgInterval;
+}
+declare class PgIntervalDescriptor extends PostgresCodecDescriptor<PrecisionParams> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/interval@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["interval"];
+  readonly paramsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    precision?: number;
+  }, {}>;
+  renderOutputType(params: PrecisionParams): string | undefined;
+  factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => PgIntervalCodec;
+}
+declare const pgIntervalColumn: (params?: PrecisionParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<PgIntervalCodec, PrecisionParams>;
+declare class PgJsonCodec extends CodecImpl<typeof PG_JSON_CODEC_ID, readonly [], string | JsonValue, JsonValue> {
+  encode(value: JsonValue, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string | JsonValue, _ctx: CodecCallContext): Promise<JsonValue>;
+  encodeJson(value: JsonValue): JsonValue;
+  decodeJson(json: JsonValue): JsonValue;
+}
+declare class PgJsonDescriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/json@1";
+  readonly traits: readonly [];
+  readonly targetTypes: readonly ["json"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  factory(): (ctx: CodecInstanceContext) => PgJsonCodec;
+}
+declare const pgJsonColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgJsonCodec, undefined>;
+declare class PgJsonbCodec extends CodecImpl<typeof PG_JSONB_CODEC_ID, readonly ['equality'], string | JsonValue, JsonValue> {
+  encode(value: JsonValue, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string | JsonValue, _ctx: CodecCallContext): Promise<JsonValue>;
+  encodeJson(value: JsonValue): JsonValue;
+  decodeJson(json: JsonValue): JsonValue;
+}
+declare class PgJsonbDescriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/jsonb@1";
+  readonly traits: readonly ["equality"];
+  readonly targetTypes: readonly ["jsonb"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  factory(): (ctx: CodecInstanceContext) => PgJsonbCodec;
+}
+declare const pgJsonbColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<PgJsonbCodec, undefined>;
+declare class PgCharDescriptor extends PostgresCodecDescriptor<LengthParams> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/char@1";
+  readonly targetTypes: readonly ["character"];
+  readonly traits: readonly ["equality", "order", "textual"];
+  readonly paramsSchema: StandardSchemaV1<{
+    readonly length?: number;
+  }, {
+    readonly length?: number;
+  }>;
+  renderOutputType(params: LengthParams): string | undefined;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(_params: LengthParams): (ctx: CodecInstanceContext) => SqlCharCodec;
+}
+declare const pgCharColumn: (params?: LengthParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<SqlCharCodec, LengthParams>;
+declare class PgVarcharDescriptor extends PostgresCodecDescriptor<LengthParams> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/varchar@1";
+  readonly targetTypes: readonly ["character varying"];
+  readonly traits: readonly ["equality", "order", "textual"];
+  readonly paramsSchema: StandardSchemaV1<{
+    readonly length?: number;
+  }, {
+    readonly length?: number;
+  }>;
+  renderOutputType(params: LengthParams): string | undefined;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(_params: LengthParams): (ctx: CodecInstanceContext) => SqlVarcharCodec;
+}
+declare const pgVarcharColumn: (params?: LengthParams) => import("@prisma/orm-framework/components/codec").ColumnSpec<SqlVarcharCodec, LengthParams>;
+declare class PgIntDescriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/int@1";
+  readonly targetTypes: readonly ["int4"];
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly paramsSchema: StandardSchemaV1<void, void>;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(): (ctx: CodecInstanceContext) => SqlIntCodec;
+}
+declare const pgIntColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqlIntCodec, undefined>;
+declare class PgFloatDescriptor extends PostgresCodecDescriptor<void> {
+  protected nativeType(): string;
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly codecId: "pg/float@1";
+  readonly targetTypes: readonly ["float8"];
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly paramsSchema: StandardSchemaV1<void, void>;
+  renderValueLiteral(value: JsonValue): string | undefined;
+  factory(): (ctx: CodecInstanceContext) => SqlFloatCodec;
+}
+declare const pgFloatColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqlFloatCodec, undefined>;
+//#endregion
+export { pgUuidColumn as $, isPgEnumParams as A, pgInt2Column as B, PgTimeDescriptor as C, PgUuidDescriptor as D, PgTimetzDescriptor as E, pgEnumDescriptor as F, pgJsonColumn as G, pgInt8Column as H, pgFloat4Column as I, pgTextColumn as J, pgJsonbColumn as K, pgFloat8Column as L, pgBoolColumn as M, pgCharColumn as N, PgVarbitDescriptor as O, pgDateColumn as P, pgTimetzColumn as Q, pgFloatColumn as R, PgTextDescriptor as S, PgTimestamptzDescriptor as T, pgIntColumn as U, pgInt4Column as V, pgIntervalColumn as W, pgTimestampColumn as X, pgTimeColumn as Y, pgTimestamptzColumn as Z, PgInterval as _, PgDateDescriptor as a, PgJsonbDescriptor as b, PgEnumParams as c, PgFloatDescriptor as d, pgVarbitColumn as et, PgInetDescriptor as f, PgIntDescriptor as g, PgInt8Descriptor as h, PgCharDescriptor as i, pgBitColumn as j, PgVarcharDescriptor as k, PgFloat4Descriptor as l, PgInt4Descriptor as m, PgBoolDescriptor as n, postgresQualifyColumnType as nt, PgEnumCodec as o, PgInt2Descriptor as p, pgNumericColumn as q, PgByteaDescriptor as r, PgEnumDescriptor as s, PgBitDescriptor as t, pgVarcharColumn as tt, PgFloat8Descriptor as u, PgIntervalDescriptor as v, PgTimestampDescriptor as w, PgNumericDescriptor as x, PgJsonDescriptor as y, pgInetColumn as z };
+//# sourceMappingURL=codecs-Cvqvb9pV-Cdc51FKY.d.mts.map

package/dist/codecs-Cvqvb9pV-Cdc51FKY.d.mts.map

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

package/dist/codecs-DBn-uIv-.d.mts

@@ -0,0 +1,15 @@
+import { i as PostgresCodecDescriptorRegistry } from "./codec-descriptor-Bec_zukr-BfvtUqhm.mjs";
+import "./codecs-Cvqvb9pV-Cdc51FKY.mjs";
+import { CodecDescriptorRegistry } from "@prisma/orm-family-sql/relational-core/query-lane-context";
+//#region ../../../3-targets/3-targets/postgres/dist/codecs.d.mts
+//#region src/core/registry.d.ts
+/**
+ * Registry of every codec descriptor shipped by `@internal/target-postgres`.
+ *
+ * Public consumer surface for the postgres codec set: the postgres adapter and any other consumer that needs to enumerate or look up a postgres codec by id consumes this rather than the raw descriptor array. See ADR 208.
+ */
+declare const postgresCodecRegistry: CodecDescriptorRegistry;
+declare const postgresCodecDescriptorRegistry: PostgresCodecDescriptorRegistry;
+//#endregion
+export { postgresCodecRegistry as n, postgresCodecDescriptorRegistry as t };
+//# sourceMappingURL=codecs-DBn-uIv-.d.mts.map

package/dist/codecs-DBn-uIv-.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-DBn-uIv-.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/codecs.d.mts"],"mappings":";;;;;;;;;;cASc,uBAAuB;cACvB,iCAAiC"}