@prisma-next/target-postgres 0.4.1 → 0.4.3

package/dist/codec-ids-CojIXVf9.mjs

@@ -0,0 +1,29 @@
+import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma-next/sql-relational-core/ast";
+
+//#region src/core/codec-ids.ts
+const PG_TEXT_CODEC_ID = "pg/text@1";
+const PG_ENUM_CODEC_ID = "pg/enum@1";
+const PG_CHAR_CODEC_ID = "pg/char@1";
+const PG_VARCHAR_CODEC_ID = "pg/varchar@1";
+const PG_INT_CODEC_ID = "pg/int@1";
+const PG_INT2_CODEC_ID = "pg/int2@1";
+const PG_INT4_CODEC_ID = "pg/int4@1";
+const PG_INT8_CODEC_ID = "pg/int8@1";
+const PG_FLOAT_CODEC_ID = "pg/float@1";
+const PG_FLOAT4_CODEC_ID = "pg/float4@1";
+const PG_FLOAT8_CODEC_ID = "pg/float8@1";
+const PG_NUMERIC_CODEC_ID = "pg/numeric@1";
+const PG_BOOL_CODEC_ID = "pg/bool@1";
+const PG_BIT_CODEC_ID = "pg/bit@1";
+const PG_VARBIT_CODEC_ID = "pg/varbit@1";
+const PG_TIMESTAMP_CODEC_ID = "pg/timestamp@1";
+const PG_TIMESTAMPTZ_CODEC_ID = "pg/timestamptz@1";
+const PG_TIME_CODEC_ID = "pg/time@1";
+const PG_TIMETZ_CODEC_ID = "pg/timetz@1";
+const PG_INTERVAL_CODEC_ID = "pg/interval@1";
+const PG_JSON_CODEC_ID = "pg/json@1";
+const PG_JSONB_CODEC_ID = "pg/jsonb@1";
+
+//#endregion
+export { SQL_CHAR_CODEC_ID as C, SQL_TIMESTAMP_CODEC_ID as D, SQL_TEXT_CODEC_ID as E, SQL_VARCHAR_CODEC_ID as O, PG_VARCHAR_CODEC_ID as S, SQL_INT_CODEC_ID as T, PG_TIMESTAMPTZ_CODEC_ID as _, PG_FLOAT4_CODEC_ID as a, PG_TIME_CODEC_ID as b, PG_INT2_CODEC_ID as c, PG_INTERVAL_CODEC_ID as d, PG_INT_CODEC_ID as f, PG_TEXT_CODEC_ID as g, PG_NUMERIC_CODEC_ID as h, PG_ENUM_CODEC_ID as i, PG_INT4_CODEC_ID as l, PG_JSON_CODEC_ID as m, PG_BOOL_CODEC_ID as n, PG_FLOAT8_CODEC_ID as o, PG_JSONB_CODEC_ID as p, PG_CHAR_CODEC_ID as r, PG_FLOAT_CODEC_ID as s, PG_BIT_CODEC_ID as t, PG_INT8_CODEC_ID as u, PG_TIMESTAMP_CODEC_ID as v, SQL_FLOAT_CODEC_ID as w, PG_VARBIT_CODEC_ID as x, PG_TIMETZ_CODEC_ID as y };
+//# sourceMappingURL=codec-ids-CojIXVf9.mjs.map

package/dist/codec-ids-CojIXVf9.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-ids-CojIXVf9.mjs","names":[],"sources":["../src/core/codec-ids.ts"],"sourcesContent":["export {\n  SQL_CHAR_CODEC_ID,\n  SQL_FLOAT_CODEC_ID,\n  SQL_INT_CODEC_ID,\n  SQL_TEXT_CODEC_ID,\n  SQL_TIMESTAMP_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '@prisma-next/sql-relational-core/ast';\nexport const PG_TEXT_CODEC_ID = 'pg/text@1' as const;\nexport const PG_ENUM_CODEC_ID = 'pg/enum@1' as const;\nexport const PG_CHAR_CODEC_ID = 'pg/char@1' as const;\nexport const PG_VARCHAR_CODEC_ID = 'pg/varchar@1' as const;\nexport const PG_INT_CODEC_ID = 'pg/int@1' as const;\nexport const PG_INT2_CODEC_ID = 'pg/int2@1' as const;\nexport const PG_INT4_CODEC_ID = 'pg/int4@1' as const;\nexport const PG_INT8_CODEC_ID = 'pg/int8@1' as const;\nexport const PG_FLOAT_CODEC_ID = 'pg/float@1' as const;\nexport const PG_FLOAT4_CODEC_ID = 'pg/float4@1' as const;\nexport const PG_FLOAT8_CODEC_ID = 'pg/float8@1' as const;\nexport const PG_NUMERIC_CODEC_ID = 'pg/numeric@1' as const;\nexport const PG_BOOL_CODEC_ID = 'pg/bool@1' as const;\nexport const PG_BIT_CODEC_ID = 'pg/bit@1' as const;\nexport const PG_VARBIT_CODEC_ID = 'pg/varbit@1' as const;\nexport const PG_TIMESTAMP_CODEC_ID = 'pg/timestamp@1' as const;\nexport const PG_TIMESTAMPTZ_CODEC_ID = 'pg/timestamptz@1' as const;\nexport const PG_TIME_CODEC_ID = 'pg/time@1' as const;\nexport const PG_TIMETZ_CODEC_ID = 'pg/timetz@1' as const;\nexport const PG_INTERVAL_CODEC_ID = 'pg/interval@1' as const;\nexport const PG_JSON_CODEC_ID = 'pg/json@1' as const;\nexport const PG_JSONB_CODEC_ID = 'pg/jsonb@1' as const;\n"],"mappings":";;;AAQA,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,sBAAsB;AACnC,MAAa,kBAAkB;AAC/B,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,oBAAoB;AACjC,MAAa,qBAAqB;AAClC,MAAa,qBAAqB;AAClC,MAAa,sBAAsB;AACnC,MAAa,mBAAmB;AAChC,MAAa,kBAAkB;AAC/B,MAAa,qBAAqB;AAClC,MAAa,wBAAwB;AACrC,MAAa,0BAA0B;AACvC,MAAa,mBAAmB;AAChC,MAAa,qBAAqB;AAClC,MAAa,uBAAuB;AACpC,MAAa,mBAAmB;AAChC,MAAa,oBAAoB"}

package/dist/codec-ids.d.mts

@@ -0,0 +1,28 @@
+import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma-next/sql-relational-core/ast";
+
+//#region src/core/codec-ids.d.ts
+declare const PG_TEXT_CODEC_ID: "pg/text@1";
+declare const PG_ENUM_CODEC_ID: "pg/enum@1";
+declare const PG_CHAR_CODEC_ID: "pg/char@1";
+declare const PG_VARCHAR_CODEC_ID: "pg/varchar@1";
+declare const PG_INT_CODEC_ID: "pg/int@1";
+declare const PG_INT2_CODEC_ID: "pg/int2@1";
+declare const PG_INT4_CODEC_ID: "pg/int4@1";
+declare const PG_INT8_CODEC_ID: "pg/int8@1";
+declare const PG_FLOAT_CODEC_ID: "pg/float@1";
+declare const PG_FLOAT4_CODEC_ID: "pg/float4@1";
+declare const PG_FLOAT8_CODEC_ID: "pg/float8@1";
+declare const PG_NUMERIC_CODEC_ID: "pg/numeric@1";
+declare const PG_BOOL_CODEC_ID: "pg/bool@1";
+declare const PG_BIT_CODEC_ID: "pg/bit@1";
+declare const PG_VARBIT_CODEC_ID: "pg/varbit@1";
+declare const PG_TIMESTAMP_CODEC_ID: "pg/timestamp@1";
+declare const PG_TIMESTAMPTZ_CODEC_ID: "pg/timestamptz@1";
+declare const PG_TIME_CODEC_ID: "pg/time@1";
+declare const PG_TIMETZ_CODEC_ID: "pg/timetz@1";
+declare const PG_INTERVAL_CODEC_ID: "pg/interval@1";
+declare const PG_JSON_CODEC_ID: "pg/json@1";
+declare const PG_JSONB_CODEC_ID: "pg/jsonb@1";
+//#endregion
+export { PG_BIT_CODEC_ID, PG_BOOL_CODEC_ID, PG_CHAR_CODEC_ID, PG_ENUM_CODEC_ID, PG_FLOAT4_CODEC_ID, PG_FLOAT8_CODEC_ID, PG_FLOAT_CODEC_ID, PG_INT2_CODEC_ID, PG_INT4_CODEC_ID, PG_INT8_CODEC_ID, PG_INTERVAL_CODEC_ID, PG_INT_CODEC_ID, PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID, PG_NUMERIC_CODEC_ID, PG_TEXT_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID, PG_TIMESTAMP_CODEC_ID, PG_TIMETZ_CODEC_ID, PG_TIME_CODEC_ID, PG_VARBIT_CODEC_ID, PG_VARCHAR_CODEC_ID, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID };
+//# sourceMappingURL=codec-ids.d.mts.map

package/dist/codec-ids.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-ids.d.mts","names":[],"sources":["../src/core/codec-ids.ts"],"sourcesContent":[],"mappings":";;;cAQa;cACA;AADA,cAEA,gBAFuC,EAAA,WAAA;AACvC,cAEA,mBAFuC,EAAA,cAAA;AACvC,cAEA,eAFuC,EAAA,UAAA;AACvC,cAEA,gBAF6C,EAAA,WAAA;AAC7C,cAEA,gBAFqC,EAAA,WAAA;AACrC,cAEA,gBAFuC,EAAA,WAAA;AACvC,cAEA,iBAFuC,EAAA,YAAA;AACvC,cAEA,kBAFuC,EAAA,aAAA;AACvC,cAEA,kBAFyC,EAAA,aAAA;AACzC,cAEA,mBAF2C,EAAA,cAAA;AAC3C,cAEA,gBAF2C,EAAA,WAAA;AAC3C,cAEA,eAF6C,EAAA,UAAA;AAC7C,cAEA,kBAFuC,EAAA,aAAA;AACvC,cAEA,qBAFqC,EAAA,gBAAA;AACrC,cAEA,uBAF2C,EAAA,kBAAA;AAC3C,cAEA,gBAFiD,EAAA,WAAA;AACjD,cAEA,kBAFqD,EAAA,aAAA;AACrD,cAEA,oBAFuC,EAAA,eAAA;AACvC,cAEA,gBAF2C,EAAA,WAAA;AAC3C,cAEA,iBAF+C,EAAA,YAAA"}

package/dist/codec-ids.mjs

@@ -0,0 +1,3 @@
+import { C as SQL_CHAR_CODEC_ID, D as SQL_TIMESTAMP_CODEC_ID, E as SQL_TEXT_CODEC_ID, O as SQL_VARCHAR_CODEC_ID, S as PG_VARCHAR_CODEC_ID, T as SQL_INT_CODEC_ID, _ as PG_TIMESTAMPTZ_CODEC_ID, a as PG_FLOAT4_CODEC_ID, b as PG_TIME_CODEC_ID, c as PG_INT2_CODEC_ID, d as PG_INTERVAL_CODEC_ID, f as PG_INT_CODEC_ID, g as PG_TEXT_CODEC_ID, h as PG_NUMERIC_CODEC_ID, i as PG_ENUM_CODEC_ID, l as PG_INT4_CODEC_ID, m as PG_JSON_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT8_CODEC_ID, p as PG_JSONB_CODEC_ID, r as PG_CHAR_CODEC_ID, s as PG_FLOAT_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT8_CODEC_ID, v as PG_TIMESTAMP_CODEC_ID, w as SQL_FLOAT_CODEC_ID, x as PG_VARBIT_CODEC_ID, y as PG_TIMETZ_CODEC_ID } from "./codec-ids-CojIXVf9.mjs";
+
+export { PG_BIT_CODEC_ID, PG_BOOL_CODEC_ID, PG_CHAR_CODEC_ID, PG_ENUM_CODEC_ID, PG_FLOAT4_CODEC_ID, PG_FLOAT8_CODEC_ID, PG_FLOAT_CODEC_ID, PG_INT2_CODEC_ID, PG_INT4_CODEC_ID, PG_INT8_CODEC_ID, PG_INTERVAL_CODEC_ID, PG_INT_CODEC_ID, PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID, PG_NUMERIC_CODEC_ID, PG_TEXT_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID, PG_TIMESTAMP_CODEC_ID, PG_TIMETZ_CODEC_ID, PG_TIME_CODEC_ID, PG_VARBIT_CODEC_ID, PG_VARCHAR_CODEC_ID, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID };

package/dist/codec-types.d.mts

@@ -0,0 +1,42 @@
+import { r as dataTypes, t as CodecTypes$1 } from "./codecs-CE5EUsNM.mjs";
+import { JsonValue } from "@prisma-next/contract/types";
+
+//#region src/exports/codec-types.d.ts
+
+type CodecTypes = CodecTypes$1;
+type Branded<T, Shape extends Record<string, unknown>> = T & { readonly [K in keyof Shape]: Shape[K] };
+type BrandedString<Shape extends Record<string, unknown>> = Branded<string, Shape>;
+type Char<N extends number> = BrandedString<{
+  __charLength: N;
+}>;
+type Varchar<N extends number> = BrandedString<{
+  __varcharLength: N;
+}>;
+type Numeric<P extends number, S extends number | undefined = undefined> = BrandedString<{
+  __numericPrecision: P;
+  __numericScale: S;
+}>;
+type Bit<N extends number> = BrandedString<{
+  __bitLength: N;
+}>;
+type VarBit<N extends number> = BrandedString<{
+  __varbitLength: N;
+}>;
+type Timestamp<P extends number | undefined = undefined> = BrandedString<{
+  __timestampPrecision: P;
+}>;
+type Timestamptz<P extends number | undefined = undefined> = BrandedString<{
+  __timestamptzPrecision: P;
+}>;
+type Time<P extends number | undefined = undefined> = BrandedString<{
+  __timePrecision: P;
+}>;
+type Timetz<P extends number | undefined = undefined> = BrandedString<{
+  __timetzPrecision: P;
+}>;
+type Interval<P extends number | undefined = undefined> = BrandedString<{
+  __intervalPrecision: P;
+}>;
+//#endregion
+export { Bit, Char, CodecTypes, Interval, type JsonValue, Numeric, Time, Timestamp, Timestamptz, Timetz, VarBit, Varchar, dataTypes };
+//# sourceMappingURL=codec-types.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types.d.mts","names":[],"sources":["../src/exports/codec-types.ts"],"sourcesContent":[],"mappings":";;;;;AA8BY,KAXA,UAAA,GAAa,YAWY;KANhC,OASiB,CAAA,CAAA,EAAA,cATQ,MASR,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,GATmC,CASnC,GAAA,iBACJ,MATK,KASL,GATa,KASb,CATmB,CASnB,CAAA,EAFgE;KAJ7E,aAI0F,CAAA,cAJ9D,MAI8D,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,GAJnC,OAImC,CAAA,MAAA,EAJnB,KAImB,CAAA;AAInF,KANA,IAMG,CAAA,UAAqB,MAAA,CAAA,GANC,aAMY,CAAA;EACrC,YAAM,EAPiD,CAOjD;AAClB,CAAA,CAAA;AAGY,KAVA,OAUW,CAAA,UAAA,MAA6C,CAAA,GAV5B,aAUyC,CAAA;EAGrE,eAAI,EAbyD,CAazD;AAChB,CAAA,CAAA;AAGY,KAhBA,OAgBQ,CAAA,UACG,MAD0C,EAAA,UAAa,MAAA,GAAA,SAAA,GAAA,SAAA,CAAA,GAhBI,aAgBJ,CAAA;sBAfxD;kBACJ;;KAEN,wBAAwB;eAA6B;;KACrD,2BAA2B;kBAAgC;;KAC3D,sDAAsD;wBAC1C;;KAEZ,wDAAwD;0BAC1C;;KAEd,iDAAiD;mBAAiC;;KAClF,mDAAmD;qBAC1C;;KAET,qDAAqD;uBAC1C"}

package/dist/codec-types.mjs

@@ -0,0 +1,3 @@
+import { n as dataTypes } from "./codecs-dzZ_dMpK.mjs";
+
+export { dataTypes };

package/dist/codecs-CE5EUsNM.d.mts

@@ -0,0 +1,323 @@
+import * as _prisma_next_sql_relational_core_ast0 from "@prisma-next/sql-relational-core/ast";
+import { Codec } from "@prisma-next/sql-relational-core/ast";
+import { JsonValue } from "@prisma-next/contract/types";
+
+//#region src/core/codecs.d.ts
+
+declare const codecs: _prisma_next_sql_relational_core_ast0.CodecDefBuilder<{
+  char: Codec<"sql/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  varchar: Codec<"sql/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  int: Codec<"sql/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  float: Codec<"sql/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  "sql-text": Codec<"sql/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  "sql-timestamp": Codec<"sql/timestamp@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
+  text: Codec<"pg/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  character: Codec<"pg/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  "character varying": Codec<"pg/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+  integer: Codec<"pg/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  "double precision": Codec<"pg/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  int4: Codec<"pg/int4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  int2: Codec<"pg/int2@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  int8: Codec<"pg/int8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  float4: Codec<"pg/float4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  float8: Codec<"pg/float8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+  numeric: Codec<"pg/numeric@1", readonly ["equality", "order", "numeric"], string, string, Record<string, unknown>, unknown>;
+  timestamp: Codec<"pg/timestamp@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
+  timestamptz: Codec<"pg/timestamptz@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
+  time: Codec<"pg/time@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+  timetz: Codec<"pg/timetz@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+  bool: Codec<"pg/bool@1", readonly ["equality", "boolean"], boolean, boolean, Record<string, unknown>, unknown>;
+  bit: Codec<"pg/bit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+  "bit varying": Codec<"pg/varbit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+  interval: Codec<"pg/interval@1", readonly ["equality", "order"], string | Record<string, unknown>, string, Record<string, unknown>, unknown>;
+  enum: Codec<"pg/enum@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+  json: Codec<"pg/json@1", readonly [], string | number | boolean | {
+    readonly [key: string]: JsonValue;
+  } | readonly JsonValue[] | null, string | number | boolean | {
+    readonly [key: string]: JsonValue;
+  } | readonly JsonValue[] | null, Record<string, unknown>, unknown>;
+} & Record<"jsonb", Codec<"pg/jsonb@1", readonly ["equality"], string | number | boolean | {
+  readonly [key: string]: JsonValue;
+} | readonly JsonValue[] | null, string | number | boolean | {
+  readonly [key: string]: JsonValue;
+} | readonly JsonValue[] | null, Record<string, unknown>, unknown>>>;
+declare const codecDefinitions: {
+  readonly char: {
+    readonly typeId: "sql/char@1";
+    readonly scalar: "char";
+    readonly codec: Codec<"sql/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly varchar: {
+    readonly typeId: "sql/varchar@1";
+    readonly scalar: "varchar";
+    readonly codec: Codec<"sql/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly int: {
+    readonly typeId: "sql/int@1";
+    readonly scalar: "int";
+    readonly codec: Codec<"sql/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+    readonly input: number;
+    readonly output: number;
+    readonly jsType: number;
+  };
+  readonly float: {
+    readonly typeId: "sql/float@1";
+    readonly scalar: "float";
+    readonly codec: Codec<"sql/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+    readonly input: number;
+    readonly output: number;
+    readonly jsType: number;
+  };
+  readonly "sql-text": {
+    readonly typeId: "sql/text@1";
+    readonly scalar: "sql-text";
+    readonly codec: Codec<"sql/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly "sql-timestamp": {
+    readonly typeId: "sql/timestamp@1";
+    readonly scalar: "sql-timestamp";
+    readonly codec: Codec<"sql/timestamp@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
+    readonly input: Date;
+    readonly output: Date;
+    readonly jsType: Date;
+  };
+  readonly text: {
+    readonly typeId: "pg/text@1";
+    readonly scalar: "text";
+    readonly codec: Codec<"pg/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly character: {
+    readonly typeId: "pg/char@1";
+    readonly scalar: "character";
+    readonly codec: Codec<"pg/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly "character varying": {
+    readonly typeId: "pg/varchar@1";
+    readonly scalar: "character varying";
+    readonly codec: Codec<"pg/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly integer: {
+    readonly typeId: "pg/int@1";
+    readonly scalar: "integer";
+    readonly codec: Codec<"pg/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+    readonly input: number;
+    readonly output: number;
+    readonly jsType: number;
+  };
+  readonly "double precision": {
+    readonly typeId: "pg/float@1";
+    readonly scalar: "double precision";
+    readonly codec: Codec<"pg/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+    readonly input: number;
+    readonly output: number;
+    readonly jsType: number;
+  };
+  readonly int4: {
+    readonly typeId: "pg/int4@1";
+    readonly scalar: "int4";
+    readonly codec: Codec<"pg/int4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+    readonly input: number;
+    readonly output: number;
+    readonly jsType: number;
+  };
+  readonly int2: {
+    readonly typeId: "pg/int2@1";
+    readonly scalar: "int2";
+    readonly codec: Codec<"pg/int2@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+    readonly input: number;
+    readonly output: number;
+    readonly jsType: number;
+  };
+  readonly int8: {
+    readonly typeId: "pg/int8@1";
+    readonly scalar: "int8";
+    readonly codec: Codec<"pg/int8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+    readonly input: number;
+    readonly output: number;
+    readonly jsType: number;
+  };
+  readonly float4: {
+    readonly typeId: "pg/float4@1";
+    readonly scalar: "float4";
+    readonly codec: Codec<"pg/float4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+    readonly input: number;
+    readonly output: number;
+    readonly jsType: number;
+  };
+  readonly float8: {
+    readonly typeId: "pg/float8@1";
+    readonly scalar: "float8";
+    readonly codec: Codec<"pg/float8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
+    readonly input: number;
+    readonly output: number;
+    readonly jsType: number;
+  };
+  readonly numeric: {
+    readonly typeId: "pg/numeric@1";
+    readonly scalar: "numeric";
+    readonly codec: Codec<"pg/numeric@1", readonly ["equality", "order", "numeric"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly timestamp: {
+    readonly typeId: "pg/timestamp@1";
+    readonly scalar: "timestamp";
+    readonly codec: Codec<"pg/timestamp@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
+    readonly input: Date;
+    readonly output: Date;
+    readonly jsType: Date;
+  };
+  readonly timestamptz: {
+    readonly typeId: "pg/timestamptz@1";
+    readonly scalar: "timestamptz";
+    readonly codec: Codec<"pg/timestamptz@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
+    readonly input: Date;
+    readonly output: Date;
+    readonly jsType: Date;
+  };
+  readonly time: {
+    readonly typeId: "pg/time@1";
+    readonly scalar: "time";
+    readonly codec: Codec<"pg/time@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly timetz: {
+    readonly typeId: "pg/timetz@1";
+    readonly scalar: "timetz";
+    readonly codec: Codec<"pg/timetz@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly bool: {
+    readonly typeId: "pg/bool@1";
+    readonly scalar: "bool";
+    readonly codec: Codec<"pg/bool@1", readonly ["equality", "boolean"], boolean, boolean, Record<string, unknown>, unknown>;
+    readonly input: boolean;
+    readonly output: boolean;
+    readonly jsType: boolean;
+  };
+  readonly bit: {
+    readonly typeId: "pg/bit@1";
+    readonly scalar: "bit";
+    readonly codec: Codec<"pg/bit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly "bit varying": {
+    readonly typeId: "pg/varbit@1";
+    readonly scalar: "bit varying";
+    readonly codec: Codec<"pg/varbit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly interval: {
+    readonly typeId: "pg/interval@1";
+    readonly scalar: "interval";
+    readonly codec: Codec<"pg/interval@1", readonly ["equality", "order"], string | Record<string, unknown>, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly enum: {
+    readonly typeId: "pg/enum@1";
+    readonly scalar: "enum";
+    readonly codec: Codec<"pg/enum@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
+    readonly input: string;
+    readonly output: string;
+    readonly jsType: string;
+  };
+  readonly json: {
+    readonly typeId: "pg/json@1";
+    readonly scalar: "json";
+    readonly codec: Codec<"pg/json@1", readonly [], string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null, string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null, Record<string, unknown>, unknown>;
+    readonly input: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
+    readonly output: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
+    readonly jsType: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
+  };
+  readonly jsonb: {
+    readonly typeId: "pg/jsonb@1";
+    readonly scalar: "jsonb";
+    readonly codec: Codec<"pg/jsonb@1", readonly ["equality"], string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null, string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null, Record<string, unknown>, unknown>;
+    readonly input: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
+    readonly output: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
+    readonly jsType: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
+  };
+};
+declare const dataTypes: {
+  readonly char: "sql/char@1";
+  readonly varchar: "sql/varchar@1";
+  readonly int: "sql/int@1";
+  readonly float: "sql/float@1";
+  readonly "sql-text": "sql/text@1";
+  readonly "sql-timestamp": "sql/timestamp@1";
+  readonly text: "pg/text@1";
+  readonly character: "pg/char@1";
+  readonly "character varying": "pg/varchar@1";
+  readonly integer: "pg/int@1";
+  readonly "double precision": "pg/float@1";
+  readonly int4: "pg/int4@1";
+  readonly int2: "pg/int2@1";
+  readonly int8: "pg/int8@1";
+  readonly float4: "pg/float4@1";
+  readonly float8: "pg/float8@1";
+  readonly numeric: "pg/numeric@1";
+  readonly timestamp: "pg/timestamp@1";
+  readonly timestamptz: "pg/timestamptz@1";
+  readonly time: "pg/time@1";
+  readonly timetz: "pg/timetz@1";
+  readonly bool: "pg/bool@1";
+  readonly bit: "pg/bit@1";
+  readonly "bit varying": "pg/varbit@1";
+  readonly interval: "pg/interval@1";
+  readonly enum: "pg/enum@1";
+  readonly json: "pg/json@1";
+  readonly jsonb: "pg/jsonb@1";
+};
+type CodecTypes = typeof codecs.CodecTypes;
+//#endregion
+export { codecDefinitions as n, dataTypes as r, CodecTypes as t };
+//# sourceMappingURL=codecs-CE5EUsNM.d.mts.map

package/dist/codecs-CE5EUsNM.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-CE5EUsNM.d.mts","names":[],"sources":["../src/core/codecs.ts"],"sourcesContent":[],"mappings":";;;;;;cA2kBM,8CAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BC;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BD,SAAA,KAAA,OAAA,CAAA,aAAA,EAAA,SAAA,CAAA,UAAA,EAAA,OAAA,EAAA,SAAA,CAAA,EAAA,MAAA,EAAA,MAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA;IA+BC,SAAA,KAAA,EAA0C,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC1C,SAA4B,MAAA,EAAA,QAAA;IAE7B,SAAU,KAAA,OAAA,CAAU,aAAO,EAAA,SAAU,CAAA,UAAA,EAAA,OAAA,EAAA,SAAA,CAAA,EAAA,MAAA,EAAA,MAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAFpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAED,UAAA,UAAoB,MAAA,CAAO"}