@prisma/orm-family-sql 8.0.0-rc.21-dev.6 → 8.0.0-rc.21-dev.8

package/dist/{data-type-CR0gi2GQ.d.mts → data-type-B-Do6RMA.d.mts}

@@ -24,6 +24,8 @@ interface SqlDataTypeSpec<Params extends SqlTypeParams = SqlTypeParams> extends
   /** The id of the type a column of this type is stored as, with the same parameters. A type stored as another declares no texts. */
   readonly storedAs?: DataTypeId;
   readonly normalize?: (params: Params) => Params;
+  /** The parameters the database catalog prints for parameters as written, when they are not their normal form: PostgreSQL prints no precision for a bare `timestamptz`, though its normal form has precision 6. */
+  readonly catalogParams?: (params: Params) => Params;
   /** The type's name from its parameters, for a type that claims a kind or whose name is its catalog text. */
   readonly render?: (params: Params) => string;
   readonly fromReported?: (reported: ReportedSqlType) => Params;
@@ -40,6 +42,8 @@ interface SqlDataTypeFacts<Params extends SqlTypeParams = SqlTypeParams> {
   readonly storedAs: DataTypeId | undefined;
   /** The normal form of `params`; parameters the type's schema refuses are returned as written. */
   readonly normalize: (params: Params) => Params;
+  /** The parameters the catalog prints for `params` as written: the declared {@link SqlDataTypeSpec.catalogParams}, or else the normal form. */
+  readonly catalogParams: (params: Params) => Params;
   readonly render: ((params: Params) => string) | undefined;
   readonly fromReported: ((reported: ReportedSqlType) => Params) | undefined;
   readonly nameIsCatalogText: boolean;
@@ -53,6 +57,10 @@ interface ResolvedSqlType {
   readonly dataType: SqlDataType;
   readonly typeParams: SqlTypeParams;
 }
+/** A type a migration writes, read as {@link ResolvedSqlType}, with its parameters also as the text writes them, before the normal form. */
+interface ResolvedWrittenSqlType extends ResolvedSqlType {
+  readonly writtenTypeParams: SqlTypeParams;
+}
 /** Declare a SQL data type, refusing a declaration that breaks a rule of the module. */
 declare function sqlDataType<Params extends SqlTypeParams = SqlTypeParams>(id: string, spec: SqlDataTypeSpec<Params>): SqlDataType<Params>;
 /** Whether the name of `type` is the text the database catalog prints, as declared by {@link SqlDataTypeSpec.nameIsCatalogText}. */
@@ -105,7 +113,7 @@ declare function sqlStorageTypeOfCodec(codecId: string, lookups: TypeLookups): S
 declare function unquotedSqlBaseNameOfCodec(codecId: string, typeParams: SqlTypeParams | undefined, lookups: TypeLookups): string;
 /** The text a migration writes for `type` with the raw `params`. */
 declare function renderSqlTypeName<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
-/** The text the database catalog prints for `type` with `params`, in their normal form. */
+/** The text the database catalog prints for `type` with `params` as written, from the parameters its catalog prints for them ({@link SqlDataTypeFacts.catalogParams}). */
 declare function renderSqlCatalogText<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
 /** Two SQL data types that would both recognise one reported type, and what each claims. */
 interface SqlDataTypeCollision {
@@ -133,11 +141,11 @@ declare function findSqlDataTypeCollision(types: readonly DataType[]): SqlDataTy
 declare function resolveReportedSqlType(reported: ReportedSqlType, dataTypes: readonly DataType[]): ResolvedSqlType | undefined;
 /**
  * Every data type in `dataTypes` that reads `text` as a migration may write it, with its parameters
- * in normal form: any of a type's texts counts, whether written, printed by the catalog or only
+ * in normal form and as written: any of a type's texts counts, whether written, printed by the catalog or only
  * claimed. Empty when no type reads it or its parameters fail the type's schema. A type that claims
  * a kind has no texts, so it never reads one.
  */
-declare function resolveWrittenSqlTypes(text: string, dataTypes: readonly DataType[]): readonly ResolvedSqlType[];
+declare function resolveWrittenSqlTypes(text: string, dataTypes: readonly DataType[]): readonly ResolvedWrittenSqlType[];
 //#endregion
 //#region src/sql-raw.d.ts
 declare const SQL_RAW_DATA_TYPE_ID: DataTypeId;
@@ -154,5 +162,5 @@ declare function checkRawTypeText(text: string): string | undefined;
  */
 declare const sqlRawDataType: SqlDataType<SqlRawTypeParams>;
 //#endregion
-export { unquotedSqlBaseNameOfCodec as A, sqlDataType as C, sqlStorageTypeId as D, sqlStorageType as E, sqlStorageTypeOfCodec as O, sqlColumnLength as S, sqlRawDataType as T, resolveReportedSqlType as _, SqlDataTypeCollision as a, sqlBaseName as b, SqlRawTypeParams as c, checkRawTypeText as d, findSqlDataTypeCollision as f, renderSqlTypeName as g, renderSqlCatalogText as h, SqlDataType as i, validateSqlTypeParams as j, unquotedSqlBaseName as k, SqlTypeParams as l, nameIsCatalogText as m, SQL_RAW_DATA_TYPE_ID as n, SqlDataTypeFacts as o, isSqlDataType as p, SqlColumnTypeFields as r, SqlDataTypeSpec as s, ResolvedSqlType as t, SqlTypeText as u, resolveWrittenSqlTypes as v, sqlDataTypeOfCodec as w, sqlCodecColumnLength as x, sameSqlColumnType as y };
-//# sourceMappingURL=data-type-CR0gi2GQ.d.mts.map
+export { unquotedSqlBaseName as A, sqlColumnLength as C, sqlStorageType as D, sqlRawDataType as E, validateSqlTypeParams as M, sqlStorageTypeId as O, sqlCodecColumnLength as S, sqlDataTypeOfCodec as T, renderSqlTypeName as _, SqlDataType as a, sameSqlColumnType as b, SqlDataTypeSpec as c, SqlTypeText as d, checkRawTypeText as f, renderSqlCatalogText as g, nameIsCatalogText as h, SqlColumnTypeFields as i, unquotedSqlBaseNameOfCodec as j, sqlStorageTypeOfCodec as k, SqlRawTypeParams as l, isSqlDataType as m, ResolvedWrittenSqlType as n, SqlDataTypeCollision as o, findSqlDataTypeCollision as p, SQL_RAW_DATA_TYPE_ID as r, SqlDataTypeFacts as s, ResolvedSqlType as t, SqlTypeParams as u, resolveReportedSqlType as v, sqlDataType as w, sqlBaseName as x, resolveWrittenSqlTypes as y };
+//# sourceMappingURL=data-type-B-Do6RMA.d.mts.map

package/dist/data-type-B-Do6RMA.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-B-Do6RMA.d.mts","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/data-type.d.mts"],"mappings":";;;;;;;UAKU;;WAEC;;WAEA;;WAEA;;WAEA;;KAEN,gBAAgB,SAAS;UACpB,gBAAgB,eAAe,gBAAgB,uBAAuB,KAAK;WAC1E,SAAS,KAAK;WACd,iBAAiB;;WAEjB;;WAEA,WAAW;WACX,aAAa,QAAQ,WAAW;;WAEhC,iBAAiB,QAAQ,WAAW;;WAEpC,UAAU,QAAQ;WAClB,gBAAgB,UAAU,oBAAoB;;;;;;WAM9C;;UAED,iBAAiB,eAAe,gBAAgB;WAC/C,gBAAgB;WAChB;WACA,UAAU;;WAEV,YAAY,QAAQ,WAAW;;WAE/B,gBAAgB,QAAQ,WAAW;WACnC,UAAU,QAAQ;WAClB,gBAAgB,UAAU,oBAAoB;WAC9C;;UAED,YAAY,eAAe,gBAAgB,uBAAuB;WACjE,SAAS,KAAK;WACd,KAAK,iBAAiB;;;UAGvB;WACC,UAAU;WACV,YAAY;;;UAGb,+BAA+B;WAC9B,mBAAmB;;;iBAGb,YAAY,eAAe,gBAAgB,eAAe,YAAY,MAAM,gBAAgB,UAAU,YAAY;;iBAElH,kBAAkB,eAAe,eAAe,MAAM,YAAY;;iBAElE,cAAc,MAAM,WAAW,QAAQ;;iBAEvC,sBAAsB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ,gBAAgB;;;;;;iBAMvG,YAAY,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;;;;;;iBAO7E,oBAAoB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;iBAErF,mBAAmB,iBAAiB,SAAS,cAAc;;;;iBAI3D,gBAAgB,MAAM,sBAAsB,YAAY,SAAS;;iBAEjE,qBAAqB;WAC3B,QAAQ,KAAK;WACb,kBAAkB,oBAAoB;GAC9C,iBAAiB,YAAY,SAAS;;iBAExB,eAAe,MAAM,aAAa,QAAQ,KAAK,yBAAyB;;iBAExE,iBAAiB,oBAAoB,QAAQ,KAAK;;UAEzD;WACC;WACA,aAAa,SAAS;WACtB;;;;;iBAKM,kBAAkB,GAAG,qBAAqB,GAAG,qBAAqB,QAAQ,KAAK;;iBAE/E,sBAAsB,iBAAiB,SAAS,cAAc;;iBAE9D,2BAA2B,iBAAiB,YAAY,2BAA2B,SAAS;;iBAE5F,kBAAkB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;iBAEnF,qBAAqB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;UAE7F;WACC,OAAO;WACP,QAAQ;WACR;aACE;aACA;aACA;;aAEA;aACA;;;;;;;;iBAQI,yBAAyB,gBAAgB,aAAa;;;;;iBAKtD,uBAAuB,UAAU,iBAAiB,oBAAoB,aAAa;;;;;;;iBAOnF,uBAAuB,cAAc,oBAAoB,sBAAsB;;;cAGlF,sBAAsB;KAC/B;WACM;;;iBAGM,iBAAiB;;;;;;;cAOpB,gBAAgB,YAAY"}

package/dist/{data-type-BFSpaotu.mjs → data-type-BfA5F0Qf.mjs}

@@ -1,4 +1,4 @@
-import { f as sqlDataType } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
+import { f as sqlDataType } from "./sql-data-type-LVBldu1a-Bq203xWX.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { dataTypeId } from "@prisma/orm-framework/components/codec";
 import { type } from "arktype";
@@ -49,4 +49,4 @@ const sqlRawDataType = sqlDataType(SQL_RAW_DATA_TYPE_ID, {
 //#endregion
 export { checkRawTypeText as n, sqlRawDataType as r, SQL_RAW_DATA_TYPE_ID as t };
 
-//# sourceMappingURL=data-type-BFSpaotu.mjs.map
+//# sourceMappingURL=data-type-BfA5F0Qf.mjs.map

package/dist/{data-type-BFSpaotu.mjs.map → data-type-BfA5F0Qf.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"data-type-BFSpaotu.mjs","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/data-type.mjs"],"sourcesContent":["import { _ as unquotedSqlBaseName, a as renderSqlTypeName, c as sameSqlColumnType, d as sqlColumnLength, f as sqlDataType, g as sqlStorageTypeOfCodec, h as sqlStorageTypeId, i as renderSqlCatalogText, l as sqlBaseName, m as sqlStorageType, n as isSqlDataType, o as resolveReportedSqlType, p as sqlDataTypeOfCodec, r as nameIsCatalogText, s as resolveWrittenSqlTypes, t as findSqlDataTypeCollision, u as sqlCodecColumnLength, v as unquotedSqlBaseNameOfCodec, y as validateSqlTypeParams } from \"./sql-data-type-D7M-YTTY.mjs\";\nimport { structuredError } from \"@internal/utils/structured-error\";\nimport { dataTypeId } from \"@internal/framework-components/codec\";\nimport { type } from \"arktype\";\n//#region src/sql-raw.ts\nconst SQL_RAW_DATA_TYPE_ID = dataTypeId(\"sql/raw\");\nconst NAME = `(?:[A-Za-z0-9_]+|\"(?:[^\"]|\"\")+\")`;\nconst TOKEN = `${NAME}(?:\\\\((?:[A-Za-z0-9_, ]|-(?=[0-9]))*\\\\))?`;\n/**\n* The texts a raw type may be: words and double-quoted names, with each double quote inside doubled, separated by single spaces, the first\n* optionally after one schema name and a dot, each optionally followed by parentheses holding only\n* letters, digits, underscores, commas, spaces and a minus sign before a digit, then at most one\n* `[]`. Postgres prints a schema only for a type off the `search_path` that is not a base type.\n*/\nconst RAW_TYPE_TEXT = new RegExp(`^(?:${NAME}\\\\.)?${TOKEN}(?: ${TOKEN})*(?:\\\\[\\\\])?$`);\n/** Returns undefined when `text` may be written as a column's type, else the reason. */\nfunction checkRawTypeText(text) {\n\treturn RAW_TYPE_TEXT.test(text) ? void 0 : \"A raw type is one type name as the database catalog prints it, such as tsvector, double precision, geometry(Point,4326), app.email or \\\"MyType\\\"[]: words of letters, digits and underscores separated by single spaces, or double-quoted names with each double quote inside doubled; the first optionally after one schema name and a dot; each optionally followed by parentheses holding only letters, digits, underscores, commas, spaces and a minus sign before a digit; and at most one trailing [].\";\n}\nconst sqlRawParams = type({ sql: \"string\" }).narrow((params, ctx) => {\n\tconst refused = checkRawTypeText(params.sql);\n\treturn refused === void 0 || ctx.reject({\n\t\tpath: [\"sql\"],\n\t\tmessage: refused\n\t});\n});\n/**\n* The refusal of a literal value of a raw column, which has none: Prisma does not interpret a raw\n* column's values. Every literal reaches it through the data type's reader.\n*/\nfunction refuseLiteralValue() {\n\tthrow structuredError(\"CONTRACT.LITERAL_VALUES_ABSENT\", \"A raw column has no literal values, so its default cannot be a literal. Write the default as a SQL expression: sql`...`.\", {\n\t\twhy: \"Prisma does not interpret the values of a raw column, so it cannot write or compare a literal of its type.\",\n\t\tfix: \"Write the default as a sql expression, such as @default(sql`...`) in a schema or .default(sql`...`) in TypeScript.\"\n\t});\n}\n/**\n* The data type of a column whose type no other data type claims. Its `sql` parameter is the type\n* exactly as the database catalog prints it, which migrations write and verify compares. It claims\n* no reported type, so introspection never reads a column as raw. It has no literal values: it\n* declares no casts, and its reader refuses every value. ADR 273.\n*/\nconst sqlRawDataType = sqlDataType(SQL_RAW_DATA_TYPE_ID, {\n\tparams: sqlRawParams,\n\tnameIsCatalogText: true,\n\trender: ({ sql }) => sql,\n\tread: refuseLiteralValue\n});\n//#endregion\nexport { SQL_RAW_DATA_TYPE_ID, checkRawTypeText, findSqlDataTypeCollision, isSqlDataType, nameIsCatalogText, renderSqlCatalogText, renderSqlTypeName, resolveReportedSqlType, resolveWrittenSqlTypes, sameSqlColumnType, sqlBaseName, sqlCodecColumnLength, sqlColumnLength, sqlDataType, sqlDataTypeOfCodec, sqlRawDataType, sqlStorageType, sqlStorageTypeId, sqlStorageTypeOfCodec, unquotedSqlBaseName, unquotedSqlBaseNameOfCodec, validateSqlTypeParams };\n\n//# sourceMappingURL=data-type.mjs.map"],"mappings":";;;;;AAKA,MAAM,uBAAuB,WAAW,SAAS;AACjD,MAAM,OAAO;AACb,MAAM,QAAQ,GAAG,KAAK;;;;;;;AAOtB,MAAM,gBAAgB,IAAI,OAAO,OAAO,KAAK,OAAO,MAAM,MAAM,MAAM,eAAe;;AAErF,SAAS,iBAAiB,MAAM;CAC/B,OAAO,cAAc,KAAK,IAAI,IAAI,KAAK,IAAI;AAC5C;AACA,MAAM,eAAe,KAAK,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,QAAQ,QAAQ;CACpE,MAAM,UAAU,iBAAiB,OAAO,GAAG;CAC3C,OAAO,YAAY,KAAK,KAAK,IAAI,OAAO;EACvC,MAAM,CAAC,KAAK;EACZ,SAAS;CACV,CAAC;AACF,CAAC;;;;;AAKD,SAAS,qBAAqB;CAC7B,MAAM,gBAAgB,kCAAkC,4HAA4H;EACnL,KAAK;EACL,KAAK;CACN,CAAC;AACF;;;;;;;AAOA,MAAM,iBAAiB,YAAY,sBAAsB;CACxD,QAAQ;CACR,mBAAmB;CACnB,SAAS,EAAE,UAAU;CACrB,MAAM;AACP,CAAC"}
+{"version":3,"file":"data-type-BfA5F0Qf.mjs","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/data-type.mjs"],"sourcesContent":["import { _ as unquotedSqlBaseName, a as renderSqlTypeName, c as sameSqlColumnType, d as sqlColumnLength, f as sqlDataType, g as sqlStorageTypeOfCodec, h as sqlStorageTypeId, i as renderSqlCatalogText, l as sqlBaseName, m as sqlStorageType, n as isSqlDataType, o as resolveReportedSqlType, p as sqlDataTypeOfCodec, r as nameIsCatalogText, s as resolveWrittenSqlTypes, t as findSqlDataTypeCollision, u as sqlCodecColumnLength, v as unquotedSqlBaseNameOfCodec, y as validateSqlTypeParams } from \"./sql-data-type-LVBldu1a.mjs\";\nimport { structuredError } from \"@internal/utils/structured-error\";\nimport { dataTypeId } from \"@internal/framework-components/codec\";\nimport { type } from \"arktype\";\n//#region src/sql-raw.ts\nconst SQL_RAW_DATA_TYPE_ID = dataTypeId(\"sql/raw\");\nconst NAME = `(?:[A-Za-z0-9_]+|\"(?:[^\"]|\"\")+\")`;\nconst TOKEN = `${NAME}(?:\\\\((?:[A-Za-z0-9_, ]|-(?=[0-9]))*\\\\))?`;\n/**\n* The texts a raw type may be: words and double-quoted names, with each double quote inside doubled, separated by single spaces, the first\n* optionally after one schema name and a dot, each optionally followed by parentheses holding only\n* letters, digits, underscores, commas, spaces and a minus sign before a digit, then at most one\n* `[]`. Postgres prints a schema only for a type off the `search_path` that is not a base type.\n*/\nconst RAW_TYPE_TEXT = new RegExp(`^(?:${NAME}\\\\.)?${TOKEN}(?: ${TOKEN})*(?:\\\\[\\\\])?$`);\n/** Returns undefined when `text` may be written as a column's type, else the reason. */\nfunction checkRawTypeText(text) {\n\treturn RAW_TYPE_TEXT.test(text) ? void 0 : \"A raw type is one type name as the database catalog prints it, such as tsvector, double precision, geometry(Point,4326), app.email or \\\"MyType\\\"[]: words of letters, digits and underscores separated by single spaces, or double-quoted names with each double quote inside doubled; the first optionally after one schema name and a dot; each optionally followed by parentheses holding only letters, digits, underscores, commas, spaces and a minus sign before a digit; and at most one trailing [].\";\n}\nconst sqlRawParams = type({ sql: \"string\" }).narrow((params, ctx) => {\n\tconst refused = checkRawTypeText(params.sql);\n\treturn refused === void 0 || ctx.reject({\n\t\tpath: [\"sql\"],\n\t\tmessage: refused\n\t});\n});\n/**\n* The refusal of a literal value of a raw column, which has none: Prisma does not interpret a raw\n* column's values. Every literal reaches it through the data type's reader.\n*/\nfunction refuseLiteralValue() {\n\tthrow structuredError(\"CONTRACT.LITERAL_VALUES_ABSENT\", \"A raw column has no literal values, so its default cannot be a literal. Write the default as a SQL expression: sql`...`.\", {\n\t\twhy: \"Prisma does not interpret the values of a raw column, so it cannot write or compare a literal of its type.\",\n\t\tfix: \"Write the default as a sql expression, such as @default(sql`...`) in a schema or .default(sql`...`) in TypeScript.\"\n\t});\n}\n/**\n* The data type of a column whose type no other data type claims. Its `sql` parameter is the type\n* exactly as the database catalog prints it, which migrations write and verify compares. It claims\n* no reported type, so introspection never reads a column as raw. It has no literal values: it\n* declares no casts, and its reader refuses every value. ADR 273.\n*/\nconst sqlRawDataType = sqlDataType(SQL_RAW_DATA_TYPE_ID, {\n\tparams: sqlRawParams,\n\tnameIsCatalogText: true,\n\trender: ({ sql }) => sql,\n\tread: refuseLiteralValue\n});\n//#endregion\nexport { SQL_RAW_DATA_TYPE_ID, checkRawTypeText, findSqlDataTypeCollision, isSqlDataType, nameIsCatalogText, renderSqlCatalogText, renderSqlTypeName, resolveReportedSqlType, resolveWrittenSqlTypes, sameSqlColumnType, sqlBaseName, sqlCodecColumnLength, sqlColumnLength, sqlDataType, sqlDataTypeOfCodec, sqlRawDataType, sqlStorageType, sqlStorageTypeId, sqlStorageTypeOfCodec, unquotedSqlBaseName, unquotedSqlBaseNameOfCodec, validateSqlTypeParams };\n\n//# sourceMappingURL=data-type.mjs.map"],"mappings":";;;;;AAKA,MAAM,uBAAuB,WAAW,SAAS;AACjD,MAAM,OAAO;AACb,MAAM,QAAQ,GAAG,KAAK;;;;;;;AAOtB,MAAM,gBAAgB,IAAI,OAAO,OAAO,KAAK,OAAO,MAAM,MAAM,MAAM,eAAe;;AAErF,SAAS,iBAAiB,MAAM;CAC/B,OAAO,cAAc,KAAK,IAAI,IAAI,KAAK,IAAI;AAC5C;AACA,MAAM,eAAe,KAAK,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,QAAQ,QAAQ;CACpE,MAAM,UAAU,iBAAiB,OAAO,GAAG;CAC3C,OAAO,YAAY,KAAK,KAAK,IAAI,OAAO;EACvC,MAAM,CAAC,KAAK;EACZ,SAAS;CACV,CAAC;AACF,CAAC;;;;;AAKD,SAAS,qBAAqB;CAC7B,MAAM,gBAAgB,kCAAkC,4HAA4H;EACnL,KAAK;EACL,KAAK;CACN,CAAC;AACF;;;;;;;AAOA,MAAM,iBAAiB,YAAY,sBAAsB;CACxD,QAAQ;CACR,mBAAmB;CACnB,SAAS,EAAE,UAAU;CACrB,MAAM;AACP,CAAC"}

package/dist/{default-mapping-CAOONlKQ-CIg7JCfF.d.mts → default-mapping-CEISdj2g-B50Ag_F_.d.mts}

@@ -1,7 +1,7 @@
 import { DataTypeSupport } from "@prisma/orm-framework/components/authoring";
-import { ColumnDefault, ColumnDefaultLiteralInputValue, JsonValue } from "@prisma/orm-framework/contract/types";
-import { CodecDescriptor, DataTypeId } from "@prisma/orm-framework/components/codec";
-//#region ../../../2-sql-family/9-family/dist/default-mapping-CAOONlKQ.d.mts
+import { ColumnDefault } from "@prisma/orm-framework/contract/types";
+import { CodecDescriptor } from "@prisma/orm-framework/components/codec";
+//#region ../../../2-sql-family/9-family/dist/default-mapping-CEISdj2g.d.mts
 //#region src/core/psl-build/default-mapping.d.ts
 interface DefaultMappingOptions {
   readonly functionAttributes?: Readonly<Record<string, string>>;
@@ -28,12 +28,6 @@ type DefaultMappingResult = {
  * whitespace (ADR 129).
  */
 declare function mapDefault(columnDefault: ColumnDefault, options?: DefaultMappingOptions): DefaultMappingResult | undefined;
-/**
- * `value`, a value of `dataType` as `contract.json` stores it, written as the literal of a type that `dataType` takes, proven to read back as `value`: `255` for `pg/int4`, ``sql`"MyType"[]` `` for `sql/expression`. `undefined` when no literal reads back as it.
- */
-declare function writeDataTypeValue(value: JsonValue, dataType: DataTypeId, support: DataTypeSupport): string | undefined;
-/** The PSL literal a stored value is written as for the column `options` describe, or `undefined` when it has no written form that reads back as that value. */
-declare function writeDefaultLiteral(value: ColumnDefaultLiteralInputValue, options: DefaultMappingOptions | undefined): string | undefined;
 //#endregion
-export { writeDefaultLiteral as a, writeDataTypeValue as i, DefaultMappingResult as n, mapDefault as r, DefaultMappingOptions as t };
-//# sourceMappingURL=default-mapping-CAOONlKQ-CIg7JCfF.d.mts.map
+export { DefaultMappingResult as n, mapDefault as r, DefaultMappingOptions as t };
+//# sourceMappingURL=default-mapping-CEISdj2g-B50Ag_F_.d.mts.map

package/dist/default-mapping-CEISdj2g-B50Ag_F_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-mapping-CEISdj2g-B50Ag_F_.d.mts","names":[],"sources":["../../../../2-sql-family/9-family/dist/default-mapping-CEISdj2g.d.mts"],"mappings":";;;;;UAIU;WACC,qBAAqB,SAAS;;WAE9B,YAAY;;WAEZ,cAAc,KAAK;;WAEnB;;;;;WAKA;;KAEN;WACM;;;;;;;;;iBASM,WAAW,eAAe,eAAe,UAAU,wBAAwB"}

package/dist/{derived-checks-BuTkSE9l-gyx0d0dX.mjs → derived-checks-D__agoFB-Boa1MHcA.mjs}

@@ -4,14 +4,14 @@ import { r as lowerAuthoredIndex } from "./index-naming-BOcJT1B3-D-49owHA.mjs";
 import { t as lowerAuthoredCheck } from "./authored-check-naming-DTKcH2_d.mjs";
 import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-Ce1v_TDl.mjs";
 import { n as resolveColumnValueObject, t as discriminatorValueSet } from "./check-expressions-BDsLvzqN.mjs";
-import { p as sqlDataTypeOfCodec, y as validateSqlTypeParams } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
+import { p as sqlDataTypeOfCodec, y as validateSqlTypeParams } from "./sql-data-type-LVBldu1a-Bq203xWX.mjs";
 import { i as Index, s as StorageTable, t as CheckConstraint } from "./storage-table-B_MrLtQX-eWx6BgGT.mjs";
 import { n as checkConstraintInputFromSerialized } from "./serialized-index-BefvjuZ0-Bbsja7If.mjs";
 import { h as valueSetEntityKind, p as tableEntityKind } from "./entity-kinds-CgEwK0hH-D1NKoKE5.mjs";
 import { a as materializeForeignKeysAndIndexes } from "./foreign-key-materialization-CCHAR789.mjs";
 import { t as validateIndexTypes } from "./index-type-validation-DJEMmmw0.mjs";
 import { c as isMaterializedSqlNamespace, d as nonEmptyTypeParams, f as toStorageTypeInstance, o as SqlStorage, s as applyFkDefaults } from "./types-CISwoRED.mjs";
-import { h as validateStorageSemantics } from "./validators-CnQqLEIi.mjs";
+import { h as validateStorageSemantics } from "./validators-qcQteqs2.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-HVaxhALD.mjs";
 import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
@@ -27,7 +27,7 @@ import { mergeCapabilityMatrices } from "@prisma/orm-framework/components/compon
 import { encodeEnumTypeMembers, resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
 import { buildExecutionSection, computeProfileHash, computeStorageHash } from "@prisma/orm-framework/contract/hashing";
 import { applySpecifierDefaultControlPolicy } from "@prisma/orm-framework/contract/apply-specifier-default-control-policy";
-//#region ../../../2-sql-family/2-authoring/contract-ts/dist/derived-checks-BuTkSE9l.mjs
+//#region ../../../2-sql-family/2-authoring/contract-ts/dist/derived-checks-D__agoFB.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -1621,4 +1621,4 @@ function withoutDerivedChecks(tableName, table, contractDefault) {
 //#endregion
 export { refuseTypesKey as a, isValueObjectMember as i, buildSqlContractFromDefinition as n, storedAsListColumn as o, contractError as r, toOneNullabilityContradictionMessage as s, applySqlSpecifierControlPolicy as t };
 
-//# sourceMappingURL=derived-checks-BuTkSE9l-gyx0d0dX.mjs.map
+//# sourceMappingURL=derived-checks-D__agoFB-Boa1MHcA.mjs.map