@prisma/orm-target-mysql 8.0.0-rc.22-dev.10 → 8.0.0-rc.22-dev.12

package/dist/control-BvSM7mGR.d.mts

@@ -0,0 +1,396 @@
+import { t as MysqlPlanTargetDetails } from "./planner-target-details-D6g2uSp--C5NKHmCc.mjs";
+import { SqlStorage } from "@prisma/orm-family-sql/contract/types";
+import { SqlControlTargetDescriptor } from "@prisma/orm-family-sql/family/control";
+import { Contract } from "@prisma/orm-framework/contract/types";
+//#region ../../../3-targets/mysql/1-target/dist/control.d.mts
+//#region src/core/migrations/control-target.d.ts
+declare const mysqlControlTargetDescriptor: SqlControlTargetDescriptor<"mysql", MysqlPlanTargetDetails, Contract<SqlStorage<string>>>;
+//#endregion
+//#region src/core/type-constructors.d.ts
+/**
+ * The base scalars, the explicit date and time types and the convenience date and time types as type constructors. The target contributes them, so PSL and the TypeScript builder's `type.*` see the same names.
+ */
+declare const mysqlScalarTypeConstructors: {
+  readonly DateTime: {
+    readonly kind: "typeChoice";
+    readonly documentation: "A moment in time, read and written in UTC. `as` is what the application reads: jsDate (a JavaScript Date), temporal (Temporal.Instant) or string, such as \"2024-01-01T00:00:00Z\". `storage` is datetime, or timestamp, which holds 1970 to 2038.";
+    readonly args: readonly [{
+      readonly kind: "option";
+      readonly name: "as";
+      readonly values: readonly ["jsDate", "temporal", "string"];
+      readonly default: "jsDate";
+      readonly optional: true;
+    }, {
+      readonly kind: "option";
+      readonly name: "storage";
+      readonly values: readonly ["datetime", "timestamp"];
+      readonly default: "datetime";
+      readonly optional: true;
+    }, {
+      readonly kind: "value";
+      readonly dataType: "mysql/int";
+      readonly name: "precision";
+      readonly optional: true;
+    }];
+    readonly choices: readonly [{
+      readonly when: {
+        readonly as: "jsDate";
+        readonly storage: "datetime";
+      };
+      readonly type: "DatetimeJsDate";
+      readonly defaults: {
+        readonly precision: 3;
+      };
+    }, {
+      readonly when: {
+        readonly as: "temporal";
+        readonly storage: "datetime";
+      };
+      readonly type: "DatetimeTemporal";
+      readonly defaults: {
+        readonly precision: 6;
+      };
+    }, {
+      readonly when: {
+        readonly as: "string";
+        readonly storage: "datetime";
+      };
+      readonly type: "DatetimeString";
+      readonly defaults: {
+        readonly precision: 6;
+      };
+    }, {
+      readonly when: {
+        readonly as: "jsDate";
+        readonly storage: "timestamp";
+      };
+      readonly type: "TimestampJsDate";
+      readonly defaults: {
+        readonly precision: 3;
+      };
+    }, {
+      readonly when: {
+        readonly as: "temporal";
+        readonly storage: "timestamp";
+      };
+      readonly type: "TimestampTemporal";
+      readonly defaults: {
+        readonly precision: 6;
+      };
+    }, {
+      readonly when: {
+        readonly as: "string";
+        readonly storage: "timestamp";
+      };
+      readonly type: "TimestampString";
+      readonly defaults: {
+        readonly precision: 6;
+      };
+    }];
+  };
+  readonly Date: {
+    readonly kind: "typeChoice";
+    readonly documentation: "A calendar date. `as` is what the application reads: string, such as \"2024-02-29\", or temporal (Temporal.PlainDate).";
+    readonly args: readonly [{
+      readonly kind: "option";
+      readonly name: "as";
+      readonly values: readonly ["string", "temporal"];
+      readonly default: "string";
+      readonly optional: true;
+    }, {
+      readonly kind: "option";
+      readonly name: "storage";
+      readonly values: readonly ["date"];
+      readonly default: "date";
+      readonly optional: true;
+    }];
+    readonly choices: readonly [{
+      readonly when: {
+        readonly as: "string";
+        readonly storage: "date";
+      };
+      readonly type: "DateString";
+    }, {
+      readonly when: {
+        readonly as: "temporal";
+        readonly storage: "date";
+      };
+      readonly type: "DateTemporal";
+    }];
+  };
+  readonly Time: {
+    readonly kind: "typeChoice";
+    readonly documentation: "A time of day, from 00:00:00 to 23:59:59.999999. `as` is what the application reads: string, such as \"09:30:00\", or temporal (Temporal.PlainTime).";
+    readonly args: readonly [{
+      readonly kind: "option";
+      readonly name: "as";
+      readonly values: readonly ["string", "temporal"];
+      readonly default: "string";
+      readonly optional: true;
+    }, {
+      readonly kind: "option";
+      readonly name: "storage";
+      readonly values: readonly ["time"];
+      readonly default: "time";
+      readonly optional: true;
+    }, {
+      readonly kind: "value";
+      readonly dataType: "mysql/int";
+      readonly name: "precision";
+      readonly optional: true;
+    }];
+    readonly choices: readonly [{
+      readonly when: {
+        readonly as: "string";
+        readonly storage: "time";
+      };
+      readonly type: "TimeString";
+      readonly defaults: {
+        readonly precision: 6;
+      };
+    }, {
+      readonly when: {
+        readonly as: "temporal";
+        readonly storage: "time";
+      };
+      readonly type: "TimeTemporal";
+      readonly defaults: {
+        readonly precision: 6;
+      };
+    }];
+  };
+  readonly Duration: {
+    readonly kind: "typeChoice";
+    readonly documentation: "A length of time, stored as MySQL varchar(191), since MySQL has no interval type. `as` is what the application reads: string, an ISO 8601 duration such as \"PT1H30M\".";
+    readonly args: readonly [{
+      readonly kind: "option";
+      readonly name: "as";
+      readonly values: readonly ["string"];
+      readonly default: "string";
+      readonly optional: true;
+    }, {
+      readonly kind: "option";
+      readonly name: "storage";
+      readonly values: readonly ["varchar"];
+      readonly default: "varchar";
+      readonly optional: true;
+    }];
+    readonly choices: readonly [{
+      readonly when: {
+        readonly as: "string";
+        readonly storage: "varchar";
+      };
+      readonly type: "DurationString";
+    }];
+  };
+  readonly DatetimeJsDate: {
+    readonly inferred: true;
+    readonly kind: "typeConstructor";
+    readonly documentation: string;
+    readonly args: readonly [{
+      readonly kind: "value";
+      readonly dataType: "mysql/int";
+      readonly name: "precision";
+      readonly optional: true;
+    }];
+    readonly output: {
+      readonly codecId: "mysql/datetime@1";
+      readonly typeParams: {
+        readonly precision: {
+          readonly kind: "arg";
+          readonly index: 0;
+        };
+      };
+    };
+  };
+  readonly DatetimeTemporal: {
+    readonly kind: "typeConstructor";
+    readonly documentation: string;
+    readonly args: readonly [{
+      readonly kind: "value";
+      readonly dataType: "mysql/int";
+      readonly name: "precision";
+      readonly optional: true;
+    }];
+    readonly output: {
+      readonly codecId: "mysql/datetime-temporal@1";
+      readonly typeParams: {
+        readonly precision: {
+          readonly kind: "arg";
+          readonly index: 0;
+        };
+      };
+    };
+  };
+  readonly DatetimeString: {
+    readonly kind: "typeConstructor";
+    readonly documentation: string;
+    readonly args: readonly [{
+      readonly kind: "value";
+      readonly dataType: "mysql/int";
+      readonly name: "precision";
+      readonly optional: true;
+    }];
+    readonly output: {
+      readonly codecId: "mysql/datetime-string@1";
+      readonly typeParams: {
+        readonly precision: {
+          readonly kind: "arg";
+          readonly index: 0;
+        };
+      };
+    };
+  };
+  readonly TimestampJsDate: {
+    readonly inferred: true;
+    readonly kind: "typeConstructor";
+    readonly documentation: string;
+    readonly args: readonly [{
+      readonly kind: "value";
+      readonly dataType: "mysql/int";
+      readonly name: "precision";
+      readonly optional: true;
+    }];
+    readonly output: {
+      readonly codecId: "mysql/timestamp-date@1";
+      readonly typeParams: {
+        readonly precision: {
+          readonly kind: "arg";
+          readonly index: 0;
+        };
+      };
+    };
+  };
+  readonly TimestampTemporal: {
+    readonly kind: "typeConstructor";
+    readonly documentation: string;
+    readonly args: readonly [{
+      readonly kind: "value";
+      readonly dataType: "mysql/int";
+      readonly name: "precision";
+      readonly optional: true;
+    }];
+    readonly output: {
+      readonly codecId: "mysql/timestamp-temporal@1";
+      readonly typeParams: {
+        readonly precision: {
+          readonly kind: "arg";
+          readonly index: 0;
+        };
+      };
+    };
+  };
+  readonly TimestampString: {
+    readonly kind: "typeConstructor";
+    readonly documentation: string;
+    readonly args: readonly [{
+      readonly kind: "value";
+      readonly dataType: "mysql/int";
+      readonly name: "precision";
+      readonly optional: true;
+    }];
+    readonly output: {
+      readonly codecId: "mysql/timestamp-string@1";
+      readonly typeParams: {
+        readonly precision: {
+          readonly kind: "arg";
+          readonly index: 0;
+        };
+      };
+    };
+  };
+  readonly DateString: {
+    readonly kind: "typeConstructor";
+    readonly inferred: true;
+    readonly documentation: "A calendar date stored as MySQL date and represented as ISO 8601 text, such as 2024-02-29.";
+    readonly output: {
+      readonly codecId: "mysql/date-string@1";
+    };
+  };
+  readonly DateTemporal: {
+    readonly kind: "typeConstructor";
+    readonly documentation: "A calendar date stored as MySQL date and represented as Temporal.PlainDate.";
+    readonly output: {
+      readonly codecId: "mysql/date-temporal@1";
+    };
+  };
+  readonly TimeString: {
+    readonly inferred: true;
+    readonly kind: "typeConstructor";
+    readonly documentation: string;
+    readonly args: readonly [{
+      readonly kind: "value";
+      readonly dataType: "mysql/int";
+      readonly name: "precision";
+      readonly optional: true;
+    }];
+    readonly output: {
+      readonly codecId: "mysql/time-string@1";
+      readonly typeParams: {
+        readonly precision: {
+          readonly kind: "arg";
+          readonly index: 0;
+        };
+      };
+    };
+  };
+  readonly TimeTemporal: {
+    readonly kind: "typeConstructor";
+    readonly documentation: string;
+    readonly args: readonly [{
+      readonly kind: "value";
+      readonly dataType: "mysql/int";
+      readonly name: "precision";
+      readonly optional: true;
+    }];
+    readonly output: {
+      readonly codecId: "mysql/time-temporal@1";
+      readonly typeParams: {
+        readonly precision: {
+          readonly kind: "arg";
+          readonly index: 0;
+        };
+      };
+    };
+  };
+  readonly DurationString: {
+    readonly kind: "typeConstructor";
+    readonly inferred: true;
+    readonly documentation: "A length of time stored as MySQL varchar(191), so that it can be indexed, and represented as the ISO 8601 duration it was written as, such as PT1H30M.";
+    readonly output: {
+      readonly codecId: "mysql/duration-string@1";
+      readonly typeParams: {
+        readonly length: 191;
+      };
+    };
+  };
+  readonly String: {
+    readonly kind: "typeConstructor";
+    readonly documentation: "Text of at most 191 characters, stored as MySQL varchar(191) so that it can be indexed.";
+    readonly output: {
+      readonly codecId: "sql/varchar@1";
+      readonly typeParams: {
+        readonly length: 191;
+      };
+    };
+  };
+  readonly Int: {
+    readonly kind: "typeConstructor";
+    readonly inferred: true;
+    readonly documentation: "A signed 32-bit integer stored as MySQL int and represented as a JavaScript number.";
+    readonly output: {
+      readonly codecId: "mysql/int@1";
+    };
+  };
+  readonly BigInt: {
+    readonly kind: "typeConstructor";
+    readonly inferred: true;
+    readonly documentation: "A signed 64-bit integer stored as MySQL bigint and represented as a JavaScript bigint.";
+    readonly output: {
+      readonly codecId: "mysql/bigint@1";
+    };
+  };
+};
+//#endregion
+export { mysqlScalarTypeConstructors as n, mysqlControlTargetDescriptor as t };
+//# sourceMappingURL=control-BvSM7mGR.d.mts.map

package/dist/control-BvSM7mGR.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-BvSM7mGR.d.mts","names":[],"sources":["../../../../3-targets/mysql/1-target/dist/control.d.mts"],"mappings":";;;;;;cAKc,8BAA8B,oCAAoC,wBAAwB,SAAS;;;;;;cAMnG;WACH;aACE;aACA;aACA;eACE;eACA;eACA;eACA;eACA;;eAEA;eACA;eACA;eACA;eACA;;eAEA;eACA;eACA;eACA;;aAEF;eACE;iBACE;iBACA;;eAEF;eACA;iBACE;;;eAGF;iBACE;iBACA;;eAEF;eACA;iBACE;;;eAGF;iBACE;iBACA;;eAEF;eACA;iBACE;;;eAGF;iBACE;iBACA;;eAEF;eACA;iBACE;;;eAGF;iBACE;iBACA;;eAEF;eACA;iBACE;;;eAGF;iBACE;iBACA;;eAEF;eACA;iBACE;;;;WAIN;aACE;aACA;aACA;eACE;eACA;eACA;eACA;eACA;;eAEA;eACA;eACA;eACA;eACA;;aAEF;eACE;iBACE;iBACA;;eAEF;;eAEA;iBACE;iBACA;;eAEF;;;WAGJ;aACE;aACA;aACA;eACE;eACA;eACA;eACA;eACA;;eAEA;eACA;eACA;eACA;eACA;;eAEA;eACA;eACA;eACA;;aAEF;eACE;iBACE;iBACA;;eAEF;eACA;iBACE;;;eAGF;iBACE;iBACA;;eAEF;eACA;iBACE;;;;WAIN;aACE;aACA;aACA;eACE;eACA;eACA;eACA;eACA;;eAEA;eACA;eACA;eACA;eACA;;aAEF;eACE;iBACE;iBACA;;eAEF;;;WAGJ;aACE;aACA;aACA;aACA;eACE;eACA;eACA;eACA;;aAEF;eACE;eACA;iBACE;mBACE;mBACA;;;;;WAKR;aACE;aACA;aACA;eACE;eACA;eACA;eACA;;aAEF;eACE;eACA;iBACE;mBACE;mBACA;;;;;WAKR;aACE;aACA;aACA;eACE;eACA;eACA;eACA;;aAEF;eACE;eACA;iBACE;mBACE;mBACA;;;;;WAKR;aACE;aACA;aACA;aACA;eACE;eACA;eACA;eACA;;aAEF;eACE;eACA;iBACE;mBACE;mBACA;;;;;WAKR;aACE;aACA;aACA;eACE;eACA;eACA;eACA;;aAEF;eACE;eACA;iBACE;mBACE;mBACA;;;;;WAKR;aACE;aACA;aACA;eACE;eACA;eACA;eACA;;aAEF;eACE;eACA;iBACE;mBACE;mBACA;;;;;WAKR;aACE;aACA;aACA;aACA;eACE;;;WAGJ;aACE;aACA;aACA;eACE;;;WAGJ;aACE;aACA;aACA;aACA;eACE;eACA;eACA;eACA;;aAEF;eACE;eACA;iBACE;mBACE;mBACA;;;;;WAKR;aACE;aACA;aACA;eACE;eACA;eACA;eACA;;aAEF;eACE;eACA;iBACE;mBACE;mBACA;;;;;WAKR;aACE;aACA;aACA;aACA;eACE;eACA;iBACE;;;;WAIN;aACE;aACA;aACA;eACE;eACA;iBACE;;;;WAIN;aACE;aACA;aACA;aACA;eACE;;;WAGJ;aACE;aACA;aACA;aACA;eACE"}

package/dist/{control-Ez_PtlFI.d.mts → control-MoPFgSaQ.d.mts}

@@ -1,4 +1,4 @@
-import { t as MysqlCodecRegistry } from "./codecs-DM61agRr.mjs";
+import { i as MysqlCodecRegistry } from "./codecs-C_twedMx.mjs";
 import { r as MysqlDdlNode } from "./nodes-xc0cR0_c-2YbhgEjb.mjs";
 import "./ddl-CT6DPEqg.mjs";
 import { DataType } from "@prisma/orm-framework/components/codec";
@@ -118,4 +118,4 @@ declare function buildMysqlSchemaIR(rows: MysqlCatalogRows, dataTypes: readonly
 declare const mysqlAdapterDescriptor: SqlControlAdapterDescriptor<'mysql'>;
 //#endregion
 export { mysqlAdapterDescriptor as i, MysqlControlAdapter as n, buildMysqlSchemaIR as r, MysqlCatalogRows as t };
-//# sourceMappingURL=control-Ez_PtlFI.d.mts.map
+//# sourceMappingURL=control-MoPFgSaQ.d.mts.map

package/dist/{control-Ez_PtlFI.d.mts.map → control-MoPFgSaQ.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"control-Ez_PtlFI.d.mts","names":[],"sources":["../../../../3-targets/mysql/2-adapter/dist/control.d.mts"],"mappings":";;;;;;;;;;;;UAUU;WACC;WACA;WACA;;;;KAIN,SAAS;;;;cAIA,+BAA+B;;mBAE1B;mBACA;WACR;WACA;WACA;;EAET,YAAY,eAAe,oBAAoB,4BAA4B;EAC3E,yCAAyC;EACzC,uCAAuC;EACvC,MAAM,KAAK,cAAc,UAAU;EACnC,sBAAsB,KAAK,cAAc,eAAe,QAAQ;EAChE,oBAAoB,QAAQ,WAAW,gBAAgB;EACvD,WAAW,QAAQ,QAAQ,gBAAgB,QAAQ;EACnD,eAAe,QAAQ,SAAS,QAAQ,oBAAoB;EAC5D,WAAW,QAAQ,QAAQ,iBAAiB,iBAAiB;EAC7D,aAAa,QAAQ,QAAQ,eAAe,aAAa,oBAAoB;EAC7E,WAAW,QAAQ,QAAQ,eAAe,aAAa,oBAAoB;EAC3E,aAAa,QAAQ,QAAQ,eAAe,sBAAsB,aAAa,oBAAoB;EACnG,iBAAiB,QAAQ,QAAQ,eAAe;aACrC;aACA;aACA;aACA;aACA;aACA;MACP;;EAEJ,WAAW,SAAS,SAAS;;EAE7B,eAAe,GAAG,QAAQ,QAAQ,YAAY,QAAQ,KAAK,QAAQ;EACnE,gBAAgB,GAAG,QAAQ,QAAQ,UAAU,QAAQ,KAAK,QAAQ;EAClE,WAAW,QAAQ,QAAQ,qBAAqB,QAAQ;;;;UAIhD;WACC;WACA;WACA;WACA;WACA;WACA;WACA;;UAED;WACC;WACA;WACA;WACA;WACA;WACA;;UAED;WACC;WACA;WACA;;UAED;WACC;WACA;WACA;WACA;;WAEA;WACA;WACA;WACA;WACA;;;UAGD;WACC;WACA,kBAAkB;WAClB,kBAAkB;WAClB,sBAAsB;WACtB,sBAAsB;;;UAGvB;;WAEC,gBAAgB,mBAAmB;;WAEnC,sBAAsB,mBAAmB;;;KAG/C,sBAAsB,mBAAmB,oBAAoB,uBAAuB,QAAQ,KAAK;;;;iBAIrF,mBAAmB,MAAM,kBAAkB,oBAAoB,YAAY,oBAAoB,oBAAoB,WAAW,kBAAkB,QAAQ;;;cAG3J,wBAAwB"}
+{"version":3,"file":"control-MoPFgSaQ.d.mts","names":[],"sources":["../../../../3-targets/mysql/2-adapter/dist/control.d.mts"],"mappings":";;;;;;;;;;;;UAUU;WACC;WACA;WACA;;;;KAIN,SAAS;;;;cAIA,+BAA+B;;mBAE1B;mBACA;WACR;WACA;WACA;;EAET,YAAY,eAAe,oBAAoB,4BAA4B;EAC3E,yCAAyC;EACzC,uCAAuC;EACvC,MAAM,KAAK,cAAc,UAAU;EACnC,sBAAsB,KAAK,cAAc,eAAe,QAAQ;EAChE,oBAAoB,QAAQ,WAAW,gBAAgB;EACvD,WAAW,QAAQ,QAAQ,gBAAgB,QAAQ;EACnD,eAAe,QAAQ,SAAS,QAAQ,oBAAoB;EAC5D,WAAW,QAAQ,QAAQ,iBAAiB,iBAAiB;EAC7D,aAAa,QAAQ,QAAQ,eAAe,aAAa,oBAAoB;EAC7E,WAAW,QAAQ,QAAQ,eAAe,aAAa,oBAAoB;EAC3E,aAAa,QAAQ,QAAQ,eAAe,sBAAsB,aAAa,oBAAoB;EACnG,iBAAiB,QAAQ,QAAQ,eAAe;aACrC;aACA;aACA;aACA;aACA;aACA;MACP;;EAEJ,WAAW,SAAS,SAAS;;EAE7B,eAAe,GAAG,QAAQ,QAAQ,YAAY,QAAQ,KAAK,QAAQ;EACnE,gBAAgB,GAAG,QAAQ,QAAQ,UAAU,QAAQ,KAAK,QAAQ;EAClE,WAAW,QAAQ,QAAQ,qBAAqB,QAAQ;;;;UAIhD;WACC;WACA;WACA;WACA;WACA;WACA;WACA;;UAED;WACC;WACA;WACA;WACA;WACA;WACA;;UAED;WACC;WACA;WACA;;UAED;WACC;WACA;WACA;WACA;;WAEA;WACA;WACA;WACA;WACA;;;UAGD;WACC;WACA,kBAAkB;WAClB,kBAAkB;WAClB,sBAAsB;WACtB,sBAAsB;;;UAGvB;;WAEC,gBAAgB,mBAAmB;;WAEnC,sBAAsB,mBAAmB;;;KAG/C,sBAAsB,mBAAmB,oBAAoB,uBAAuB,QAAQ,KAAK;;;;iBAIrF,mBAAmB,MAAM,kBAAkB,oBAAoB,YAAY,oBAAoB,oBAAoB,WAAW,kBAAkB,QAAQ;;;cAG3J,wBAAwB"}

package/dist/data-type-entries-C7VH2IHc-D1d5I8zF.mjs

@@ -0,0 +1,59 @@
+import { C as mysqlTimestampText, S as mysqlTimestamp, _ as mysqlInt, b as mysqlTime, c as mysqlDateText, d as mysqlDatetimeText, f as mysqlDuration, l as mysqlDatetime, m as mysqlDurationText, r as mysqlBigint, s as mysqlDate, v as mysqlText, x as mysqlTimeText } from "./data-types-DOaaPS93-DBkMJyh1.mjs";
+import { createNumberClassifier, numeralText, signedRange } from "@prisma/orm-framework/components/codec";
+//#region ../../../3-targets/mysql/1-target/dist/data-type-entries-C7VH2IHc.mjs
+const classifyMysqlNumber = createNumberClassifier({ integers: [{
+	type: mysqlInt.id,
+	form: "number",
+	...signedRange(32)
+}, {
+	type: mysqlBigint.id,
+	form: "text",
+	...signedRange(64)
+}] });
+/** A tag whose body is a date, time or duration in ISO 8601, read into the value its type stores. */
+function storedTextTag(tag, parse, documentation) {
+	return {
+		written: {
+			kind: "tag",
+			tag,
+			parse
+		},
+		print: (value) => String(value),
+		documentation
+	};
+}
+function printNumber(value) {
+	return typeof value === "number" ? numeralText(value) : String(value);
+}
+function mysqlDataTypeEntries() {
+	return {
+		[mysqlText.id]: {
+			written: {
+				kind: "plain",
+				syntax: "string",
+				parse: (text) => text
+			},
+			print: (value) => String(value),
+			documentation: "Text."
+		},
+		[mysqlBigint.id]: {
+			written: {
+				kind: "plain",
+				syntax: "number",
+				types: [mysqlInt.id, mysqlBigint.id],
+				classify: classifyMysqlNumber
+			},
+			print: printNumber,
+			documentation: "A whole number, whose type is the narrowest MySQL integer type that holds it."
+		},
+		[mysqlDatetime.id]: storedTextTag("datetime", mysqlDatetimeText, "A date and time in UTC without an offset, as in datetime`2024-01-01T00:00:00`, in the years 1000 to 9999."),
+		[mysqlTimestamp.id]: storedTextTag("timestamp", mysqlTimestampText, "A date and time in UTC without an offset, as in timestamp`2024-01-01T00:00:00`, from 1970-01-01T00:00:01 to 2038-01-19T03:14:07.999999."),
+		[mysqlDate.id]: storedTextTag("date", mysqlDateText, "A calendar date, as in date`2024-02-29`, in the years 1000 to 9999."),
+		[mysqlTime.id]: storedTextTag("time", mysqlTimeText, "A time of day without a UTC offset, as in time`09:30:00`, from 00:00:00 to 23:59:59.999999."),
+		[mysqlDuration.id]: storedTextTag("duration", mysqlDurationText, "A length of time, as in duration`PT1H30M`. Reads an ISO 8601 duration and stores it as written.")
+	};
+}
+//#endregion
+export { mysqlDataTypeEntries as t };
+
+//# sourceMappingURL=data-type-entries-C7VH2IHc-D1d5I8zF.mjs.map

package/dist/data-type-entries-C7VH2IHc-D1d5I8zF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-entries-C7VH2IHc-D1d5I8zF.mjs","names":[],"sources":["../../../../3-targets/mysql/1-target/dist/data-type-entries-C7VH2IHc.mjs"],"sourcesContent":["import { C as mysqlTimestampText, S as mysqlTimestamp, _ as mysqlInt, b as mysqlTime, c as mysqlDateText, d as mysqlDatetimeText, f as mysqlDuration, l as mysqlDatetime, m as mysqlDurationText, r as mysqlBigint, s as mysqlDate, v as mysqlText, x as mysqlTimeText } from \"./data-types-DOaaPS93.mjs\";\nimport { createNumberClassifier, numeralText, signedRange } from \"@internal/framework-components/codec\";\n//#region src/core/data-type-entries.ts\nconst classifyMysqlNumber = createNumberClassifier({ integers: [{\n\ttype: mysqlInt.id,\n\tform: \"number\",\n\t...signedRange(32)\n}, {\n\ttype: mysqlBigint.id,\n\tform: \"text\",\n\t...signedRange(64)\n}] });\n/** A tag whose body is a date, time or duration in ISO 8601, read into the value its type stores. */\nfunction storedTextTag(tag, parse, documentation) {\n\treturn {\n\t\twritten: {\n\t\t\tkind: \"tag\",\n\t\t\ttag,\n\t\t\tparse\n\t\t},\n\t\tprint: (value) => String(value),\n\t\tdocumentation\n\t};\n}\nfunction printNumber(value) {\n\treturn typeof value === \"number\" ? numeralText(value) : String(value);\n}\nfunction mysqlDataTypeEntries() {\n\treturn {\n\t\t[mysqlText.id]: {\n\t\t\twritten: {\n\t\t\t\tkind: \"plain\",\n\t\t\t\tsyntax: \"string\",\n\t\t\t\tparse: (text) => text\n\t\t\t},\n\t\t\tprint: (value) => String(value),\n\t\t\tdocumentation: \"Text.\"\n\t\t},\n\t\t[mysqlBigint.id]: {\n\t\t\twritten: {\n\t\t\t\tkind: \"plain\",\n\t\t\t\tsyntax: \"number\",\n\t\t\t\ttypes: [mysqlInt.id, mysqlBigint.id],\n\t\t\t\tclassify: classifyMysqlNumber\n\t\t\t},\n\t\t\tprint: printNumber,\n\t\t\tdocumentation: \"A whole number, whose type is the narrowest MySQL integer type that holds it.\"\n\t\t},\n\t\t[mysqlDatetime.id]: storedTextTag(\"datetime\", mysqlDatetimeText, \"A date and time in UTC without an offset, as in datetime`2024-01-01T00:00:00`, in the years 1000 to 9999.\"),\n\t\t[mysqlTimestamp.id]: storedTextTag(\"timestamp\", mysqlTimestampText, \"A date and time in UTC without an offset, as in timestamp`2024-01-01T00:00:00`, from 1970-01-01T00:00:01 to 2038-01-19T03:14:07.999999.\"),\n\t\t[mysqlDate.id]: storedTextTag(\"date\", mysqlDateText, \"A calendar date, as in date`2024-02-29`, in the years 1000 to 9999.\"),\n\t\t[mysqlTime.id]: storedTextTag(\"time\", mysqlTimeText, \"A time of day without a UTC offset, as in time`09:30:00`, from 00:00:00 to 23:59:59.999999.\"),\n\t\t[mysqlDuration.id]: storedTextTag(\"duration\", mysqlDurationText, \"A length of time, as in duration`PT1H30M`. Reads an ISO 8601 duration and stores it as written.\")\n\t};\n}\n//#endregion\nexport { mysqlDataTypeEntries as t };\n\n//# sourceMappingURL=data-type-entries-C7VH2IHc.mjs.map"],"mappings":";;;AAGA,MAAM,sBAAsB,uBAAuB,EAAE,UAAU,CAAC;CAC/D,MAAM,SAAS;CACf,MAAM;CACN,GAAG,YAAY,EAAE;AAClB,GAAG;CACF,MAAM,YAAY;CAClB,MAAM;CACN,GAAG,YAAY,EAAE;AAClB,CAAC,EAAE,CAAC;;AAEJ,SAAS,cAAc,KAAK,OAAO,eAAe;CACjD,OAAO;EACN,SAAS;GACR,MAAM;GACN;GACA;EACD;EACA,QAAQ,UAAU,OAAO,KAAK;EAC9B;CACD;AACD;AACA,SAAS,YAAY,OAAO;CAC3B,OAAO,OAAO,UAAU,WAAW,YAAY,KAAK,IAAI,OAAO,KAAK;AACrE;AACA,SAAS,uBAAuB;CAC/B,OAAO;GACL,UAAU,KAAK;GACf,SAAS;IACR,MAAM;IACN,QAAQ;IACR,QAAQ,SAAS;GAClB;GACA,QAAQ,UAAU,OAAO,KAAK;GAC9B,eAAe;EAChB;GACC,YAAY,KAAK;GACjB,SAAS;IACR,MAAM;IACN,QAAQ;IACR,OAAO,CAAC,SAAS,IAAI,YAAY,EAAE;IACnC,UAAU;GACX;GACA,OAAO;GACP,eAAe;EAChB;GACC,cAAc,KAAK,cAAc,YAAY,mBAAmB,2GAA2G;GAC3K,eAAe,KAAK,cAAc,aAAa,oBAAoB,yIAAyI;GAC5M,UAAU,KAAK,cAAc,QAAQ,eAAe,qEAAqE;GACzH,UAAU,KAAK,cAAc,QAAQ,eAAe,6FAA6F;GACjJ,cAAc,KAAK,cAAc,YAAY,mBAAmB,iGAAiG;CACnK;AACD"}

package/dist/{data-types-SXrh0Lou.d.mts → data-types-C-rfxpgB.d.mts}

@@ -1,8 +1,8 @@
-import "./data-types-BpihGKoK-BMW-m4EN.mjs";
+import "./data-types-D2HAT-Qf-CRI506c0.mjs";
 import { DataTypeAuthoringEntry } from "@prisma/orm-framework/components/authoring";
 //#region ../../../3-targets/mysql/1-target/dist/data-types.d.mts
 //#region src/core/data-type-entries.d.ts
 declare function mysqlDataTypeEntries(): Readonly<Record<string, DataTypeAuthoringEntry>>;
 //#endregion
 export { mysqlDataTypeEntries as t };
-//# sourceMappingURL=data-types-SXrh0Lou.d.mts.map
+//# sourceMappingURL=data-types-C-rfxpgB.d.mts.map

package/dist/data-types-C-rfxpgB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-types-C-rfxpgB.d.mts","names":[],"sources":["../../../../3-targets/mysql/1-target/dist/data-types.d.mts"],"mappings":";;;;iBAGiB,wBAAwB,SAAS,eAAe"}

package/dist/data-types-D2HAT-Qf-CRI506c0.d.mts

@@ -0,0 +1,88 @@
+import { DataType, DataTypeId } from "@prisma/orm-framework/components/codec";
+//#region ../../../3-targets/mysql/1-target/dist/data-types-D2HAT-Qf.d.mts
+//#region src/core/data-types.d.ts
+declare const mysqlText: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+/** A signed 32-bit integer, stored as a JSON number. */
+declare const mysqlInt: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+/** A signed 64-bit integer, stored as digit text so that no digit is lost. */
+declare const mysqlBigint: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+/** The length of `varchar`, which MySQL requires, up to the largest it accepts. */
+declare const mysqlVarcharParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  length: number;
+}, {}>;
+declare const mysqlVarchar: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  length: number;
+}>;
+/** The length of `char`, at most 255; a bare `char` is `char(1)`. */
+declare const mysqlCharParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  length?: number;
+}, {}>;
+declare const mysqlChar: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  length?: number;
+}>;
+/** The fractional-second precision of `datetime`, `timestamp` and `time`, 0 to 6; MySQL prints a precision of 0 as the bare type. */
+declare const mysqlDatetimeParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  precision?: number;
+}, {}>;
+/** The years MySQL holds in a `datetime` and a `date`. */
+declare const MYSQL_DATETIME_RANGE: {
+  readonly earliest: "1000-01-01T00:00:00";
+  readonly latest: "9999-12-31T23:59:59.999999";
+};
+/** The instants MySQL holds in a `timestamp`, in UTC. */
+declare const MYSQL_TIMESTAMP_RANGE: {
+  readonly earliest: "1970-01-01T00:00:01";
+  readonly latest: "2038-01-19T03:14:07.999999";
+};
+/**
+ * The value of `mysql/datetime`: a date and time without a time zone, ISO 8601 text with a `T` and no trailing zeros in the fraction, within MySQL's range. Throws `CONTRACT.CAST_REFUSED` for text that names no such date and time.
+ */
+declare function mysqlDatetimeText(text: string): string;
+/**
+ * The value of `mysql/timestamp`: the UTC date and time of an instant from 1970-01-01T00:00:01 to 2038-01-19T03:14:07.999999, in the form `mysql/datetime` stores. Throws `CONTRACT.CAST_REFUSED` for text that names no such date and time.
+ */
+declare function mysqlTimestampText(text: string): string;
+/** The value of `mysql/date`: a calendar date as ISO 8601 text, `2024-02-29`, in the years 1000 to 9999. Throws `CONTRACT.CAST_REFUSED` for other text. */
+declare function mysqlDateText(text: string): string;
+/**
+ * The value of `mysql/time`: a time of day from 00:00:00 to 23:59:59.999999, ISO 8601 text with no trailing zeros in the fraction. MySQL's `time` also holds a negative time and hours past 23, which name no time of day, so they are refused. Throws `CONTRACT.CAST_REFUSED` for other text.
+ */
+declare function mysqlTimeText(text: string): string;
+/** The value of `mysql/duration`: an ISO 8601 duration, stored as written. Throws `CONTRACT.CAST_REFUSED` for other text. */
+declare function mysqlDurationText(text: string): string;
+declare const mysqlDatetime: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+}>;
+/** An instant from 1970 to 2038, which MySQL converts between the session's time zone and UTC; every session runs in UTC. */
+declare const mysqlTimestamp: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+}>;
+declare const mysqlDate: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const mysqlTime: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+}>;
+/** The length of the `varchar` a duration column is stored in. A codec reference with none, as a raw parameter writes, reads and writes the same values. */
+declare const mysqlDurationParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  length?: number;
+}, {}>;
+/** A length of time, stored in a `varchar` column as the ISO 8601 duration it was written as, `PT1H30M`, so that MySQL can index it. MySQL has no interval type, and equal durations can be written differently, `P1D` and `PT24H`, so a duration keeps its spelling. ADR 315. */
+declare const mysqlDuration: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+/** The members of a native enum column, in the order they are declared. */
+declare const mysqlEnumParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  values?: string[];
+}, {}>;
+/** `enum('A','B')`, the text MySQL's catalog prints for the column type, with each member a quoted literal. */
+declare function renderMysqlEnumType(values: readonly string[] | undefined): string;
+/**
+ * A native MySQL enum. Its name is the catalog text `enum('A','B')`, so `db verify` compares the members and their order with what MySQL reports (ADR 273). A column's members are its value set's, written into its parameters by the target's namespace (see `mysql-database.ts`).
+ */
+declare const mysqlEnum: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  values?: string[];
+}>;
+/** Every data type this target registers. */
+declare const mysqlDataTypes: readonly DataType[];
+/** MySQL's text data types, which a SQL discriminator column may have. */
+declare const mysqlTextDataTypes: readonly DataTypeId[];
+//#endregion
+export { mysqlTimestampText as C, renderMysqlEnumType as E, mysqlTimestamp as S, mysqlVarcharParams as T, mysqlInt as _, mysqlCharParams as a, mysqlTime as b, mysqlDateText as c, mysqlDatetimeText as d, mysqlDuration as f, mysqlEnumParams as g, mysqlEnum as h, mysqlChar as i, mysqlDatetime as l, mysqlDurationText as m, MYSQL_TIMESTAMP_RANGE as n, mysqlDataTypes as o, mysqlDurationParams as p, mysqlBigint as r, mysqlDate as s, MYSQL_DATETIME_RANGE as t, mysqlDatetimeParams as u, mysqlText as v, mysqlVarchar as w, mysqlTimeText as x, mysqlTextDataTypes as y };
+//# sourceMappingURL=data-types-D2HAT-Qf-CRI506c0.d.mts.map

package/dist/data-types-D2HAT-Qf-CRI506c0.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-types-D2HAT-Qf-CRI506c0.d.mts","names":[],"sources":["../../../../3-targets/mysql/1-target/dist/data-types-D2HAT-Qf.d.mts"],"mappings":";;;cAEc,sDAAsD,YAAY,SAAS;;cAE3E,qDAAqD,YAAY,SAAS;;cAE1E,wDAAwD,YAAY,SAAS;;cAE7E,kEAAkE;EAC9E;;cAEY,yDAAyD;EACrE;;;cAGY,+DAA+D;EAC3E;;cAEY,sDAAsD;EAClE;;;cAGY,mEAAmE;EAC/E;;;cAGY;WACH;WACA;;;cAGG;WACH;WACA;;;;;iBAKM,kBAAkB;;;;iBAIlB,mBAAmB;;iBAEnB,cAAc;;;;iBAId,cAAc;;iBAEd,kBAAkB;cACrB,0DAA0D;EACtE;;;cAGY,2DAA2D;EACvE;;cAEY,sDAAsD,YAAY,SAAS;cAC3E,sDAAsD;EAClE;;;cAGY,mEAAmE;EAC/E;;;cAGY,0DAA0D,YAAY,SAAS;;cAE/E,+DAA+D;EAC3E;;;iBAGe,oBAAoB;;;;cAIvB,sDAAsD;EAClE;;;cAGY,yBAAyB;;cAEzB,6BAA6B"}