effect 4.0.0-beta.2 → 4.0.0-beta.21

package/dist/Schema.js

@@ -2,17 +2,20 @@
  * @since 4.0.0
  */
 import * as Arr from "./Array.js";
+import * as BigDecimal_ from "./BigDecimal.js";
 import * as Cause_ from "./Cause.js";
 import * as Data from "./Data.js";
 import * as DateTime from "./DateTime.js";
 import * as Duration_ from "./Duration.js";
 import * as Effect from "./Effect.js";
-import * as Base64 from "./encoding/Base64.js";
+import * as Encoding from "./Encoding.js";
 import * as Equal from "./Equal.js";
 import * as Equivalence from "./Equivalence.js";
 import * as Exit_ from "./Exit.js";
 import { format, formatDate, formatPropertyKey } from "./Formatter.js";
 import { identity } from "./Function.js";
+import * as HashMap_ from "./HashMap.js";
+import * as HashSet_ from "./HashSet.js";
 import * as core from "./internal/core.js";
 import * as InternalAnnotations from "./internal/schema/annotations.js";
 import * as InternalArbitrary from "./internal/schema/arbitrary.js";
@@ -782,11 +785,12 @@ export function encodeKeys(mapping) {
     const fields = {};
     const reverseMapping = {};
     for (const k in self.fields) {
+      const encoded = toEncoded(self.fields[k]);
       if (Object.hasOwn(mapping, k)) {
-        fields[mapping[k]] = toEncoded(self.fields[k]);
+        fields[mapping[k]] = encoded;
         reverseMapping[mapping[k]] = k;
       } else {
-        fields[k] = self.fields[k];
+        fields[k] = encoded;
       }
     }
     return Struct(fields).pipe(decodeTo(self, Transformation.transform({
@@ -2528,6 +2532,58 @@ export const isBetweenBigInt = /*#__PURE__*/makeIsBetween({
     }
   })
 });
+/**
+ * Validates that a BigDecimal is greater than the specified value (exclusive).
+ *
+ * @category BigDecimal checks
+ * @since 4.0.0
+ */
+export const isGreaterThanBigDecimal = /*#__PURE__*/makeIsGreaterThan({
+  order: BigDecimal_.Order,
+  formatter: bd => BigDecimal_.format(bd)
+});
+/**
+ * Validates that a BigDecimal is greater than or equal to the specified value
+ * (inclusive).
+ *
+ * @category BigDecimal checks
+ * @since 4.0.0
+ */
+export const isGreaterThanOrEqualToBigDecimal = /*#__PURE__*/makeIsGreaterThanOrEqualTo({
+  order: BigDecimal_.Order,
+  formatter: bd => BigDecimal_.format(bd)
+});
+/**
+ * Validates that a BigDecimal is less than the specified value (exclusive).
+ *
+ * @category BigDecimal checks
+ * @since 4.0.0
+ */
+export const isLessThanBigDecimal = /*#__PURE__*/makeIsLessThan({
+  order: BigDecimal_.Order,
+  formatter: bd => BigDecimal_.format(bd)
+});
+/**
+ * Validates that a BigDecimal is less than or equal to the specified value
+ * (inclusive).
+ *
+ * @category BigDecimal checks
+ * @since 4.0.0
+ */
+export const isLessThanOrEqualToBigDecimal = /*#__PURE__*/makeIsLessThanOrEqualTo({
+  order: BigDecimal_.Order,
+  formatter: bd => BigDecimal_.format(bd)
+});
+/**
+ * Validates that a BigDecimal is within a specified range.
+ *
+ * @category BigDecimal checks
+ * @since 4.0.0
+ */
+export const isBetweenBigDecimal = /*#__PURE__*/makeIsBetween({
+  order: BigDecimal_.Order,
+  formatter: bd => BigDecimal_.format(bd)
+});
 /**
  * Validates that a value has at least the specified length. Works with strings
  * and arrays.
@@ -3041,6 +3097,40 @@ export function Option(value) {
 export function OptionFromNullOr(schema) {
   return NullOr(schema).pipe(decodeTo(Option(toType(schema)), Transformation.optionFromNullOr()));
 }
+/**
+ * Decodes an undefined-or value `T` to a required `Option<T>` value.
+ *
+ * Decoding:
+ * - `undefined` is decoded as `None`
+ * - other values are decoded as `Some`
+ *
+ * Encoding:
+ * - `None` is encoded as `undefined`
+ * - `Some` is encoded as the value
+ *
+ * @category Option
+ * @since 4.0.0
+ */
+export function OptionFromUndefinedOr(schema) {
+  return UndefinedOr(schema).pipe(decodeTo(Option(toType(schema)), Transformation.optionFromUndefinedOr()));
+}
+/**
+ * Decodes a nullish value `T` to a required `Option<T>` value.
+ *
+ * Decoding:
+ * - `null` and `undefined` are decoded as `None`
+ * - other values are decoded as `Some`
+ *
+ * Encoding:
+ * - `None` is encoded as `null` or `undefined` depending on the provided `options.onNoneEncoding` (defaults to `undefined`)
+ * - `Some` is encoded as the value
+ *
+ * @category Option
+ * @since 4.0.0
+ */
+export function OptionFromNullishOr(schema, options) {
+  return NullishOr(schema).pipe(decodeTo(Option(toType(schema)), Transformation.optionFromNullishOr(options)));
+}
 /**
  * Decodes an optional value `A` to a required `Option<A>` value.
  *
@@ -3225,10 +3315,10 @@ export function RedactedFromValue(value, options) {
   }));
 }
 /**
- * @category CauseFailure
+ * @category CauseReason
  * @since 4.0.0
  */
-export function CauseFailure(error, defect) {
+export function CauseReason(error, defect) {
   const schema = declareConstructor()([error, defect], ([error, defect]) => (input, ast, options) => {
     if (!Cause_.isReason(input)) {
       return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
@@ -3252,7 +3342,7 @@ export function CauseFailure(error, defect) {
       _tag: "effect/Cause/Failure"
     },
     generation: {
-      runtime: `Schema.CauseFailure(?, ?)`,
+      runtime: `Schema.CauseReason(?, ?)`,
       Type: `Cause.Failure<?, ?>`,
       importDeclaration: `import * as Cause from "effect/Cause"`
     },
@@ -3279,16 +3369,16 @@ export function CauseFailure(error, defect) {
       },
       encode: identity
     })),
-    toArbitrary: ([error, defect]) => causeFailureToArbitrary(error, defect),
-    toEquivalence: ([error, defect]) => causeFailureToEquivalence(error, defect),
-    toFormatter: ([error, defect]) => causeFailureToFormatter(error, defect)
+    toArbitrary: ([error, defect]) => causeReasonToArbitrary(error, defect),
+    toEquivalence: ([error, defect]) => causeReasonToEquivalence(error, defect),
+    toFormatter: ([error, defect]) => causeReasonToFormatter(error, defect)
   });
   return make(schema.ast, {
     error,
     defect
   });
 }
-function causeFailureToArbitrary(error, defect) {
+function causeReasonToArbitrary(error, defect) {
   return (fc, ctx) => {
     return fc.oneof(ctx?.isSuspend ? {
       maxDepth: 2,
@@ -3298,7 +3388,7 @@ function causeFailureToArbitrary(error, defect) {
     }).map(Cause_.makeInterruptReason), error.map(e => Cause_.makeFailReason(e)), defect.map(d => Cause_.makeDieReason(d)));
   };
 }
-function causeFailureToEquivalence(error, defect) {
+function causeReasonToEquivalence(error, defect) {
   return (a, b) => {
     if (a._tag !== b._tag) return false;
     switch (a._tag) {
@@ -3311,7 +3401,7 @@ function causeFailureToEquivalence(error, defect) {
     }
   };
 }
-function causeFailureToFormatter(error, defect) {
+function causeReasonToFormatter(error, defect) {
   return t => {
     switch (t._tag) {
       case "Fail":
@@ -3328,15 +3418,17 @@ function causeFailureToFormatter(error, defect) {
  * @since 4.0.0
  */
 export function Cause(error, defect) {
-  const schema = declareConstructor()([error, defect], ([error, defect]) => (input, ast, options) => {
-    if (!Cause_.isCause(input)) {
-      return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
-    }
-    const failures = Array(CauseFailure(error, defect));
-    return Effect.mapBothEager(Parser.decodeUnknownEffect(failures)(input.reasons, options), {
-      onSuccess: Cause_.fromReasons,
-      onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["failures"], issue)])
-    });
+  const schema = declareConstructor()([error, defect], ([error, defect]) => {
+    const failures = Array(CauseReason(error, defect));
+    return (input, ast, options) => {
+      if (!Cause_.isCause(input)) {
+        return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
+      }
+      return Effect.mapBothEager(Parser.decodeUnknownEffect(failures)(input.reasons, options), {
+        onSuccess: Cause_.fromReasons,
+        onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["failures"], issue)])
+      });
+    };
   }, {
     typeConstructor: {
       _tag: "effect/Cause"
@@ -3347,7 +3439,7 @@ export function Cause(error, defect) {
       importDeclaration: `import * as Cause from "effect/Cause"`
     },
     expected: "Cause",
-    toCodec: ([error, defect]) => link()(Array(CauseFailure(error, defect)), Transformation.transform({
+    toCodec: ([error, defect]) => link()(Array(CauseReason(error, defect)), Transformation.transform({
       decode: Cause_.fromReasons,
       encode: ({
         reasons: failures
@@ -3364,16 +3456,16 @@ export function Cause(error, defect) {
 }
 function causeToArbitrary(error, defect) {
   return (fc, ctx) => {
-    return fc.array(causeFailureToArbitrary(error, defect)(fc, ctx)).map(Cause_.fromReasons);
+    return fc.array(causeReasonToArbitrary(error, defect)(fc, ctx)).map(Cause_.fromReasons);
   };
 }
 function causeToEquivalence(error, defect) {
-  const failures = Equivalence.Array(causeFailureToEquivalence(error, defect));
+  const failures = Equivalence.Array(causeReasonToEquivalence(error, defect));
   return (a, b) => failures(a.reasons, b.reasons);
 }
 function causeToFormatter(error, defect) {
-  const causeFailure = causeFailureToFormatter(error, defect);
-  return t => `Cause([${t.reasons.map(causeFailure).join(", ")}])`;
+  const causeReason = causeReasonToFormatter(error, defect);
+  return t => `Cause([${t.reasons.map(causeReason).join(", ")}])`;
 }
 const ErrorJsonEncoded = /*#__PURE__*/Struct({
   message: String,
@@ -3459,23 +3551,25 @@ export const DefectWithStack = /*#__PURE__*/Union([/*#__PURE__*/ErrorJsonEncoded
  * @since 4.0.0
  */
 export function Exit(value, error, defect) {
-  const schema = declareConstructor()([value, error, defect], ([value, error, defect]) => (input, ast, options) => {
-    if (!Exit_.isExit(input)) {
-      return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
-    }
+  const schema = declareConstructor()([value, error, defect], ([value, error, defect]) => {
     const cause = Cause(error, defect);
-    switch (input._tag) {
-      case "Success":
-        return Effect.mapBothEager(Parser.decodeUnknownEffect(value)(input.value, options), {
-          onSuccess: Exit_.succeed,
-          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["value"], issue)])
-        });
-      case "Failure":
-        return Effect.mapBothEager(Parser.decodeUnknownEffect(cause)(input.cause, options), {
-          onSuccess: Exit_.failCause,
-          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["cause"], issue)])
-        });
-    }
+    return (input, ast, options) => {
+      if (!Exit_.isExit(input)) {
+        return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
+      }
+      switch (input._tag) {
+        case "Success":
+          return Effect.mapBothEager(Parser.decodeUnknownEffect(value)(input.value, options), {
+            onSuccess: Exit_.succeed,
+            onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["value"], issue)])
+          });
+        case "Failure":
+          return Effect.mapBothEager(Parser.decodeUnknownEffect(cause)(input.cause, options), {
+            onSuccess: Exit_.failCause,
+            onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["cause"], issue)])
+          });
+      }
+    };
   }, {
     typeConstructor: {
       _tag: "effect/Exit"
@@ -3544,15 +3638,17 @@ export function Exit(value, error, defect) {
  * @since 4.0.0
  */
 export function ReadonlyMap(key, value) {
-  const schema = declareConstructor()([key, value], ([key, value]) => (input, ast, options) => {
-    if (input instanceof globalThis.Map) {
-      const array = Array(Tuple([key, value]));
-      return Effect.mapBothEager(Parser.decodeUnknownEffect(array)([...input], options), {
-        onSuccess: array => new globalThis.Map(array),
-        onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["entries"], issue)])
-      });
-    }
-    return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
+  const schema = declareConstructor()([key, value], ([key, value]) => {
+    const array = Array(Tuple([key, value]));
+    return (input, ast, options) => {
+      if (input instanceof globalThis.Map) {
+        return Effect.mapBothEager(Parser.decodeUnknownEffect(array)([...input], options), {
+          onSuccess: array => new globalThis.Map(array),
+          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["entries"], issue)])
+        });
+      }
+      return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
+    };
   }, {
     typeConstructor: {
       _tag: "ReadonlyMap"
@@ -3587,20 +3683,76 @@ export function ReadonlyMap(key, value) {
     value
   });
 }
+/**
+ * Creates a schema that validates a `HashMap` where keys and values must
+ * conform to the provided schemas.
+ *
+ * @category HashMap
+ * @since 4.0.0
+ */
+export function HashMap(key, value) {
+  const schema = declareConstructor()([key, value], ([key, value]) => {
+    const entries = Array(Tuple([key, value]));
+    return (input, ast, options) => {
+      if (HashMap_.isHashMap(input)) {
+        return Effect.mapBothEager(Parser.decodeUnknownEffect(entries)(HashMap_.toEntries(input), options), {
+          onSuccess: HashMap_.fromIterable,
+          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["entries"], issue)])
+        });
+      }
+      return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
+    };
+  }, {
+    typeConstructor: {
+      _tag: "effect/HashMap"
+    },
+    generation: {
+      runtime: `Schema.HashMap(?, ?)`,
+      Type: `HashMap.HashMap<?, ?>`,
+      importDeclaration: `import * as HashMap from "effect/HashMap"`
+    },
+    expected: "HashMap",
+    toCodec: ([key, value]) => link()(Array(Tuple([key, value])), Transformation.transform({
+      decode: HashMap_.fromIterable,
+      encode: HashMap_.toEntries
+    })),
+    toArbitrary: ([key, value]) => (fc, ctx) => {
+      return fc.oneof(ctx?.isSuspend ? {
+        maxDepth: 2,
+        depthIdentifier: "HashMap"
+      } : {}, fc.constant([]), fc.array(fc.tuple(key, value), ctx?.constraints?.array)).map(HashMap_.fromIterable);
+    },
+    toEquivalence: ([key, value]) => Equal.makeCompareMap(key, value),
+    toFormatter: ([key, value]) => t => {
+      const size = HashMap_.size(t);
+      if (size === 0) {
+        return "HashMap(0) {}";
+      }
+      const entries = HashMap_.toEntries(t).sort().map(([k, v]) => `${key(k)} => ${value(v)}`);
+      return `HashMap(${size}) { ${entries.join(", ")} }`;
+    }
+  });
+  return make(schema.ast, {
+    key,
+    value
+  });
+}
 /**
  * @category ReadonlySet
  * @since 4.0.0
  */
 export function ReadonlySet(value) {
-  const schema = declareConstructor()([value], ([value]) => (input, ast, options) => {
-    if (input instanceof globalThis.Set) {
-      const array = Array(value);
-      return Effect.mapBothEager(Parser.decodeUnknownEffect(array)([...input], options), {
-        onSuccess: array => new globalThis.Set(array),
-        onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["values"], issue)])
-      });
-    }
-    return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
+  const schema = declareConstructor()([value], ([value]) => {
+    const array = Array(value);
+    return (input, ast, options) => {
+      if (input instanceof globalThis.Set) {
+        return Effect.mapBothEager(Parser.decodeUnknownEffect(array)([...input], options), {
+          onSuccess: array => new globalThis.Set(array),
+          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["values"], issue)])
+        });
+      }
+      return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
+    };
   }, {
     typeConstructor: {
       _tag: "ReadonlySet"
@@ -3634,6 +3786,58 @@ export function ReadonlySet(value) {
     value
   });
 }
+/**
+ * Creates a schema that validates a `HashSet` where values must conform to the
+ * provided schema.
+ *
+ * @category HashSet
+ * @since 4.0.0
+ */
+export function HashSet(value) {
+  const schema = declareConstructor()([value], ([value]) => {
+    const values = Array(value);
+    return (input, ast, options) => {
+      if (HashSet_.isHashSet(input)) {
+        return Effect.mapBothEager(Parser.decodeUnknownEffect(values)(Arr.fromIterable(input), options), {
+          onSuccess: HashSet_.fromIterable,
+          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["values"], issue)])
+        });
+      }
+      return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
+    };
+  }, {
+    typeConstructor: {
+      _tag: "effect/HashSet"
+    },
+    generation: {
+      runtime: `Schema.HashSet(?)`,
+      Type: `HashSet.HashSet<?>`
+    },
+    expected: "HashSet",
+    toCodec: ([value]) => link()(Array(value), Transformation.transform({
+      decode: HashSet_.fromIterable,
+      encode: Arr.fromIterable
+    })),
+    toArbitrary: ([value]) => (fc, ctx) => {
+      return fc.oneof(ctx?.isSuspend ? {
+        maxDepth: 2,
+        depthIdentifier: "HashSet"
+      } : {}, fc.constant([]), fc.array(value, ctx?.constraints?.array)).map(HashSet_.fromIterable);
+    },
+    toEquivalence: ([value]) => Equal.makeCompareSet(value),
+    toFormatter: ([value]) => t => {
+      const size = HashSet_.size(t);
+      if (size === 0) {
+        return "HashSet(0) {}";
+      }
+      const values = globalThis.Array.from(t).sort().map(v => `${value(v)}`);
+      return `HashSet(${size}) { ${values.join(", ")} }`;
+    }
+  });
+  return make(schema.ast, {
+    value
+  });
+}
 /**
  * @since 4.0.0
  */
@@ -3842,6 +4046,35 @@ export const DurationFromNanos = /*#__PURE__*/BigInt.check(isGreaterThanOrEqualT
  * @since 4.0.0
  */
 export const DurationFromMillis = /*#__PURE__*/Number.check(isGreaterThanOrEqualTo(0)).pipe(/*#__PURE__*/decodeTo(Duration, Transformation.durationFromMillis));
+/**
+ * A schema for `BigDecimal` values.
+ *
+ * **Default JSON serializer**
+ *
+ * - encodes `BigDecimal` as a `string`
+ *
+ * @since 4.0.0
+ */
+export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
+  typeConstructor: {
+    _tag: "effect/BigDecimal"
+  },
+  generation: {
+    runtime: `Schema.BigDecimal`,
+    Type: `BigDecimal.BigDecimal`,
+    importDeclaration: `import * as BigDecimal from "effect/BigDecimal"`
+  },
+  expected: "BigDecimal",
+  toCodecJson: () => link()(String.annotate({
+    expected: "a string that will be decoded as a BigDecimal"
+  }), Transformation.bigDecimalFromString),
+  toArbitrary: () => fc => fc.tuple(fc.bigInt(), fc.integer({
+    min: 0,
+    max: 20
+  })).map(([value, scale]) => BigDecimal_.make(value, scale)),
+  toFormatter: () => bd => BigDecimal_.format(bd),
+  toEquivalence: () => BigDecimal_.Equivalence
+});
 /**
  * A transformation schema that decodes a JSON-encoded string into an `unknown` value.
  *
@@ -3953,7 +4186,7 @@ export const File = /*#__PURE__*/instanceOf(globalThis.File, {
     name: String,
     lastModified: Number
   }), Transformation.transformOrFail({
-    decode: e => Result_.match(Base64.decode(e.data), {
+    decode: e => Result_.match(Encoding.decodeBase64(e.data), {
       onFailure: error => Effect.fail(new Issue.InvalidValue(Option_.some(e.data), {
         message: error.message
       })),
@@ -3969,7 +4202,7 @@ export const File = /*#__PURE__*/instanceOf(globalThis.File, {
       try: async () => {
         const bytes = new globalThis.Uint8Array(await file.arrayBuffer());
         return {
-          data: Base64.encode(bytes),
+          data: Encoding.encodeBase64(bytes),
           type: file.type,
           name: file.name,
           lastModified: file.lastModified
@@ -4383,7 +4616,7 @@ export const Uint8ArrayFromHex = /*#__PURE__*/String.annotate({
  */
 export const DateTimeUtc = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && DateTime.isUtc(u), {
   typeConstructor: {
-    _tag: "DateTime.Utc"
+    _tag: "effect/DateTime.Utc"
   },
   generation: {
     runtime: `Schema.DateTimeUtc`,
@@ -4391,10 +4624,7 @@ export const DateTimeUtc = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && D
     importDeclaration: `import * as DateTime from "effect/DateTime"`
   },
   expected: "DateTime.Utc",
-  toCodecJson: () => link()(String, {
-    decode: Getter.dateTimeUtcFromInput(),
-    encode: Getter.transform(DateTime.formatIso)
-  }),
+  toCodecJson: () => link()(String, Transformation.dateTimeUtcFromString),
   toArbitrary: () => (fc, ctx) => fc.date({
     noInvalidDate: true,
     ...ctx?.constraints?.date
@@ -4434,10 +4664,7 @@ export const DateTimeUtcFromDate = /*#__PURE__*/DateValid.pipe(/*#__PURE__*/deco
  */
 export const DateTimeUtcFromString = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a DateTime.Utc"
-}).pipe(/*#__PURE__*/decodeTo(DateTimeUtc, /*#__PURE__*/Transformation.transform({
-  decode: DateTime.makeUnsafe,
-  encode: DateTime.formatIso
-})));
+}).pipe(/*#__PURE__*/decodeTo(DateTimeUtc, Transformation.dateTimeUtcFromString));
 /**
  * A transformation schema that decodes a number into a `DateTime.Utc`.
  *
@@ -4454,18 +4681,140 @@ export const DateTimeUtcFromMillis = /*#__PURE__*/Number.pipe(/*#__PURE__*/decod
   decode: /*#__PURE__*/Getter.dateTimeUtcFromInput(),
   encode: /*#__PURE__*/Getter.transform(DateTime.toEpochMillis)
 }));
+/**
+ * A schema for `DateTime.TimeZone.Offset` values.
+ *
+ * **Default JSON serializer**
+ *
+ * - encodes `DateTime.TimeZone.Offset` as a number (offset in milliseconds)
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const TimeZoneOffset = /*#__PURE__*/declare(DateTime.isTimeZoneOffset, {
+  typeConstructor: {
+    _tag: "effect/DateTime.TimeZone.Offset"
+  },
+  generation: {
+    runtime: `Schema.TimeZoneOffset`,
+    Type: `DateTime.TimeZone.Offset`,
+    importDeclaration: `import * as DateTime from "effect/DateTime"`
+  },
+  expected: "DateTime.TimeZone.Offset",
+  toCodecJson: () => link()(Number, Transformation.timeZoneOffsetFromNumber),
+  toArbitrary: () => fc => fc.integer({
+    min: -12 * 60 * 60 * 1000,
+    max: 14 * 60 * 60 * 1000
+  }).map(n => DateTime.zoneMakeOffset(n)),
+  toFormatter: () => tz => DateTime.zoneToString(tz),
+  toEquivalence: () => (a, b) => a.offset === b.offset
+});
+/**
+ * A schema for `DateTime.TimeZone.Named` values.
+ *
+ * **Default JSON serializer**
+ *
+ * - encodes `DateTime.TimeZone.Named` as a string (IANA time zone identifier)
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const TimeZoneNamed = /*#__PURE__*/declare(DateTime.isTimeZoneNamed, {
+  typeConstructor: {
+    _tag: "effect/DateTime.TimeZone.Named"
+  },
+  generation: {
+    runtime: `Schema.TimeZoneNamed`,
+    Type: `DateTime.TimeZone.Named`,
+    importDeclaration: `import * as DateTime from "effect/DateTime"`
+  },
+  expected: "DateTime.TimeZone.Named",
+  toCodecJson: () => link()(String.annotate({
+    expected: "an IANA time zone identifier"
+  }), Transformation.timeZoneNamedFromString),
+  toArbitrary: () => fc => fc.constantFrom(...["UTC", "Europe/London", "America/New_York", "Asia/Tokyo", "Australia/Sydney"].map(DateTime.zoneMakeNamedUnsafe)),
+  toFormatter: () => tz => DateTime.zoneToString(tz),
+  toEquivalence: () => (a, b) => a.id === b.id
+});
+/**
+ * A schema for `DateTime.TimeZone` values.
+ *
+ * **Default JSON serializer**
+ *
+ * - encodes `DateTime.TimeZone` as a string (IANA identifier or offset like
+ *   `+03:00`)
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const TimeZone = /*#__PURE__*/declare(DateTime.isTimeZone, {
+  typeConstructor: {
+    _tag: "effect/DateTime.TimeZone"
+  },
+  generation: {
+    runtime: `Schema.TimeZone`,
+    Type: `DateTime.TimeZone`,
+    importDeclaration: `import * as DateTime from "effect/DateTime"`
+  },
+  expected: "DateTime.TimeZone",
+  toCodecJson: () => link()(String.annotate({
+    expected: "a time zone string (IANA identifier or offset like +03:00)"
+  }), Transformation.timeZoneFromString),
+  toArbitrary: () => fc => fc.oneof(fc.integer({
+    min: -12 * 60 * 60 * 1000,
+    max: 14 * 60 * 60 * 1000
+  }).map(n => DateTime.zoneMakeOffset(n)), fc.constantFrom(...["UTC", "Europe/London", "America/New_York", "Asia/Tokyo", "Australia/Sydney"].map(DateTime.zoneMakeNamedUnsafe))),
+  toFormatter: () => tz => DateTime.zoneToString(tz),
+  toEquivalence: () => (a, b) => DateTime.zoneToString(a) === DateTime.zoneToString(b)
+});
+/**
+ * A schema for `DateTime.Zoned` values.
+ *
+ * **Default JSON serializer**
+ *
+ * - encodes `DateTime.Zoned` as a string in the format
+ *   `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const DateTimeZoned = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && DateTime.isZoned(u), {
+  typeConstructor: {
+    _tag: "effect/DateTime.Zoned"
+  },
+  generation: {
+    runtime: `Schema.DateTimeZoned`,
+    Type: `DateTime.Zoned`,
+    importDeclaration: `import * as DateTime from "effect/DateTime"`
+  },
+  expected: "DateTime.Zoned",
+  toCodecJson: () => link()(String.annotate({
+    expected: "a zoned DateTime string (e.g. 2024-01-01T00:00:00.000+00:00[Europe/London])"
+  }), Transformation.dateTimeZonedFromString),
+  toArbitrary: () => (fc, ctx) => fc.tuple(fc.date({
+    noInvalidDate: true,
+    min: new globalThis.Date(-8640000000000000 + 14 * 60 * 60 * 1000),
+    max: new globalThis.Date(8640000000000000 - 14 * 60 * 60 * 1000),
+    ...ctx?.constraints?.date
+  }), fc.constantFrom("UTC", "Europe/London", "America/New_York", "Asia/Tokyo", "Australia/Sydney")).map(([date, zone]) => DateTime.makeZonedUnsafe(date, {
+    timeZone: zone
+  })),
+  toFormatter: () => zoned => DateTime.formatIsoZoned(zoned),
+  toEquivalence: () => DateTime.Equivalence
+});
 const immerable = /*#__PURE__*/globalThis.Symbol.for("immer-draftable");
 function makeClass(Inherited, identifier, struct, annotations) {
   const getClassSchema = getClassSchemaFactory(struct, identifier, annotations);
   const ClassTypeId = getClassTypeId(identifier); // HMR support
   return class extends Inherited {
     constructor(...[input, options]) {
+      const props = input ?? {};
       if (options?.disableValidation) {
-        super(input, options);
+        super(props, options);
       } else {
-        const validated = struct.makeUnsafe(input, options);
+        const validated = struct.makeUnsafe(props, options);
         super({
-          ...input,
+          ...props,
           ...validated
         }, {
           ...options,
@@ -4497,6 +4846,9 @@ function makeClass(Inherited, identifier, struct, annotations) {
     static makeUnsafe(input, options) {
       return new this(input, options);
     }
+    static makeOption(input, options) {
+      return Parser.makeOption(getClassSchema(this))(input, options);
+    }
     static annotate(annotations) {
       return this.rebuild(AST.annotate(this.ast, annotations));
     }