effect 4.0.0-beta.27 → 4.0.0-beta.29

package/src/Effect.ts

@@ -40,12 +40,14 @@
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Effect that may fail
  * const divide = (a: number, b: number) =>
  *   b === 0
- *     ? Effect.fail(new Error("Division by zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(a / b)
  *
  * // Error handling
@@ -146,13 +148,15 @@ const TypeId = core.EffectTypeId
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
  *
  * // A simple effect that succeeds with a value
  * const success = Effect.succeed(42)
  *
- * // An effect that may fail
- * const risky = Effect.fail(new Error("Something went wrong"))
+ * // An effect that will always fail
+ * const risky = Effect.fail(new TaskError({ message: "Something went wrong" }))
  *
  * // Effects can be composed using generator functions
  * const program = Effect.gen(function*() {
@@ -433,13 +437,15 @@ export declare namespace All {
    * @category Models
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class OopsError extends Data.TaggedError("OopsError")<{}> {}
    *
    * // EffectAny represents an Effect with any type parameters
    * const effects: Array<Effect.All.EffectAny> = [
    *   Effect.succeed(42),
    *   Effect.succeed("hello"),
-   *   Effect.fail(new Error("oops"))
+   *   Effect.fail(new OopsError())
    * ]
    * ```
    */
@@ -1518,16 +1524,18 @@ export const promise: <A>(
  *
  * @example Custom Error Handling
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TodoFetchError extends Data.TaggedError("TodoFetchError")<{ readonly cause: unknown }> {}
  *
  * const getTodo = (id: number) =>
  *   Effect.tryPromise({
  *     try: () => fetch(`https://jsonplaceholder.typicode.com/todos/${id}`),
  *     // remap the error
- *     catch: (unknown) => new Error(`something went wrong ${unknown}`)
+ *     catch: (cause) => new TodoFetchError({ cause })
  *   })
  *
- * //      ┌─── Effect<Response, Error, never>
+ * //      ┌─── Effect<Response, TodoFetchError, never>
  * //      ▼
  * const program = getTodo(1)
  * ```
@@ -1937,16 +1945,18 @@ export const bind: {
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * const addServiceCharge = (amount: number) => amount + 1
  *
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
@@ -1986,16 +1996,18 @@ export const gen: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * const addServiceCharge = (amount: number) => amount + 1
    *
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
@@ -2043,16 +2055,18 @@ export const gen: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * const addServiceCharge = (amount: number) => amount + 1
    *
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
@@ -2116,12 +2130,14 @@ export namespace gen {
  * @example
  * ```ts
  * // Title: Creating a Failed Effect
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
  *
- * //      ┌─── Effect<never, Error, never>
+ * class OperationFailedError extends Data.TaggedError("OperationFailedError")<{}> {}
+ *
+ * //      ┌─── Effect<never, OperationFailedError, never>
  * //      ▼
  * const failure = Effect.fail(
- *   new Error("Operation failed due to network error")
+ *   new OperationFailedError()
  * )
  * ```
  *
@@ -2138,9 +2154,11 @@ export const fail: <E>(error: E) => Effect<never, E> = internal.fail
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class ProgramError extends Data.TaggedError("ProgramError")<{ readonly failedAt: Date }> {}
  *
- * const program = Effect.failSync(() => new Error("Something went wrong"))
+ * const program = Effect.failSync(() => new ProgramError({ failedAt: new Date() }))
  *
  * Effect.runPromiseExit(program).then(console.log)
  * // Output: { _id: 'Exit', _tag: 'Failure', cause: ... }
@@ -2294,12 +2312,14 @@ export {
    *
    * @example Custom Error Handling
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class JsonParsingError extends Data.TaggedError("JsonParsingError")<{ readonly cause: unknown }> {}
    *
    * const parseJSON = (input: string) =>
    *   Effect.try({
    *     try: () => JSON.parse(input),
-   *     catch: (error) => new Error(`JSON parsing failed: ${error}`)
+   *     catch: (cause) => new JsonParsingError({ cause })
    *   })
    *
    * Effect.runPromiseExit(parseJSON("invalid json")).then(console.log)
@@ -2515,15 +2535,17 @@ export const fromYieldable: <Self extends Yieldable.Any, A, E, R>(
  *
  * @example
  * ```ts
- * import { Effect, pipe } from "effect"
+ * import { Data, Effect, pipe } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Function to apply a discount safely to a transaction amount
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2581,15 +2603,17 @@ export const flatMap: {
    *
    * @example
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2647,15 +2671,17 @@ export const flatMap: {
    *
    * @example
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2743,15 +2769,17 @@ export const flatten: <A, E, R, E2, R2>(self: Effect<Effect<A, E, R>, E2, R2>) =
  *
  * @example Applying a Discount Based on Fetched Amount
  * ```ts
- * import { Effect, pipe } from "effect"
+ * import { Data, Effect, pipe } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Function to apply a discount safely to a transaction amount
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2824,15 +2852,17 @@ export const andThen: {
    *
    * @example Applying a Discount Based on Fetched Amount
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2905,15 +2935,17 @@ export const andThen: {
    *
    * @example Applying a Discount Based on Fetched Amount
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2986,15 +3018,17 @@ export const andThen: {
    *
    * @example Applying a Discount Based on Fetched Amount
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -3067,15 +3101,17 @@ export const andThen: {
    *
    * @example Applying a Discount Based on Fetched Amount
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -3134,16 +3170,18 @@ export const andThen: {
  * @example
  * ```ts
  * // Title: Logging a step in a pipeline
- * import { Effect, pipe } from "effect"
+ * import { Data, Effect, pipe } from "effect"
  * import { Console } from "effect"
  *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+ *
  * // Function to apply a discount safely to a transaction amount
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * // Simulated asynchronous task to fetch a transaction amount from database
@@ -3193,16 +3231,18 @@ export const tap: {
    * @example
    * ```ts
    * // Title: Logging a step in a pipeline
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
    * import { Console } from "effect"
    *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+   *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -3252,16 +3292,18 @@ export const tap: {
    * @example
    * ```ts
    * // Title: Logging a step in a pipeline
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
    * import { Console } from "effect"
    *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+   *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -3311,16 +3353,18 @@ export const tap: {
    * @example
    * ```ts
    * // Title: Logging a step in a pipeline
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
    * import { Console } from "effect"
    *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+   *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -3370,16 +3414,18 @@ export const tap: {
    * @example
    * ```ts
    * // Title: Logging a step in a pipeline
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
    * import { Console } from "effect"
    *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+   *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -5801,17 +5847,19 @@ export const catchCauseFilter: {
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
  *
  * //      ┌─── Effect<number, string, never>
  * //      ▼
  * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
  *
- * //      ┌─── Effect<number, Error, never>
+ * //      ┌─── Effect<number, TaskError, never>
  * //      ▼
  * const mapped = Effect.mapError(
  *   simulatedTask,
- *   (message) => new Error(message)
+ *   (message) => new TaskError({ message })
  * )
  * ```
  *
@@ -5834,17 +5882,19 @@ export const mapError: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
    *
    * //      ┌─── Effect<number, string, never>
    * //      ▼
    * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
    *
-   * //      ┌─── Effect<number, Error, never>
+   * //      ┌─── Effect<number, TaskError, never>
    * //      ▼
    * const mapped = Effect.mapError(
    *   simulatedTask,
-   *   (message) => new Error(message)
+   *   (message) => new TaskError({ message })
    * )
    * ```
    *
@@ -5867,17 +5917,19 @@ export const mapError: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
    *
    * //      ┌─── Effect<number, string, never>
    * //      ▼
    * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
    *
-   * //      ┌─── Effect<number, Error, never>
+   * //      ┌─── Effect<number, TaskError, never>
    * //      ▼
    * const mapped = Effect.mapError(
    *   simulatedTask,
-   *   (message) => new Error(message)
+   *   (message) => new TaskError({ message })
    * )
    * ```
    *
@@ -5899,16 +5951,18 @@ export const mapError: {
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
  *
  * //      ┌─── Effect<number, string, never>
  * //      ▼
  * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
  *
- * //      ┌─── Effect<boolean, Error, never>
+ * //      ┌─── Effect<boolean, TaskError, never>
  * //      ▼
  * const modified = Effect.mapBoth(simulatedTask, {
- *   onFailure: (message) => new Error(message),
+ *   onFailure: (message) => new TaskError({ message }),
  *   onSuccess: (n) => n > 0
  * })
  * ```
@@ -5932,16 +5986,18 @@ export const mapBoth: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
    *
    * //      ┌─── Effect<number, string, never>
    * //      ▼
    * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
    *
-   * //      ┌─── Effect<boolean, Error, never>
+   * //      ┌─── Effect<boolean, TaskError, never>
    * //      ▼
    * const modified = Effect.mapBoth(simulatedTask, {
-   *   onFailure: (message) => new Error(message),
+   *   onFailure: (message) => new TaskError({ message }),
    *   onSuccess: (n) => n > 0
    * })
    * ```
@@ -5967,16 +6023,18 @@ export const mapBoth: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
    *
    * //      ┌─── Effect<number, string, never>
    * //      ▼
    * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
    *
-   * //      ┌─── Effect<boolean, Error, never>
+   * //      ┌─── Effect<boolean, TaskError, never>
    * //      ▼
    * const modified = Effect.mapBoth(simulatedTask, {
-   *   onFailure: (message) => new Error(message),
+   *   onFailure: (message) => new TaskError({ message }),
    *   onSuccess: (n) => n > 0
    * })
    * ```
@@ -6011,11 +6069,13 @@ export const mapBoth: {
  * @example
  * ```ts
  * // Title: Propagating an Error as a Defect
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class DivideByZeroError extends Data.TaggedError("DivideByZeroError")<{}> {}
  *
  * const divide = (a: number, b: number) =>
  *   b === 0
- *     ? Effect.fail(new Error("Cannot divide by zero"))
+ *     ? Effect.fail(new DivideByZeroError())
  *     : Effect.succeed(a / b)
  *
  * //      ┌─── Effect<number, never, never>
@@ -6024,7 +6084,7 @@ export const mapBoth: {
  *
  * Effect.runPromise(program).catch(console.error)
  * // Output:
- * // (FiberFailure) Error: Cannot divide by zero
+ * // (FiberFailure) DivideByZeroError
  * //   ...stack trace...
  * ```
  *
@@ -6783,13 +6843,15 @@ export declare namespace Retry {
  *
  * @example
  * ```ts
- * import { Effect, Schedule } from "effect"
+ * import { Data, Effect, Schedule } from "effect"
+ *
+ * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
  *
  * let attempt = 0
- * const task = Effect.callback<string, Error>((resume) => {
+ * const task = Effect.callback<string, AttemptError>((resume) => {
  *   attempt++
  *   if (attempt <= 2) {
- *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+ *     resume(Effect.fail(new AttemptError({ attempt })))
  *   } else {
  *     resume(Effect.succeed("Success!"))
  *   }
@@ -6832,13 +6894,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -6881,13 +6945,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -6930,13 +6996,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -6983,13 +7051,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -7032,13 +7102,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -7081,13 +7153,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -7134,14 +7208,16 @@ export const retry: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class NetworkTimeoutError extends Data.TaggedError("NetworkTimeoutError")<{}> {}
  *
  * let attempt = 0
  * const networkRequest = Effect.gen(function*() {
  *   attempt++
  *   yield* Console.log(`Network attempt ${attempt}`)
  *   if (attempt < 3) {
- *     return yield* Effect.fail(new Error("Network timeout"))
+ *     return yield* Effect.fail(new NetworkTimeoutError())
  *   }
  *   return "Network data"
  * })
@@ -7189,14 +7265,16 @@ export const retryOrElse: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class NetworkTimeoutError extends Data.TaggedError("NetworkTimeoutError")<{}> {}
    *
    * let attempt = 0
    * const networkRequest = Effect.gen(function*() {
    *   attempt++
    *   yield* Console.log(`Network attempt ${attempt}`)
    *   if (attempt < 3) {
-   *     return yield* Effect.fail(new Error("Network timeout"))
+   *     return yield* Effect.fail(new NetworkTimeoutError())
    *   }
    *   return "Network data"
    * })
@@ -7247,14 +7325,16 @@ export const retryOrElse: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class NetworkTimeoutError extends Data.TaggedError("NetworkTimeoutError")<{}> {}
    *
    * let attempt = 0
    * const networkRequest = Effect.gen(function*() {
    *   attempt++
    *   yield* Console.log(`Network attempt ${attempt}`)
    *   if (attempt < 3) {
-   *     return yield* Effect.fail(new Error("Network timeout"))
+   *     return yield* Effect.fail(new NetworkTimeoutError())
    *   }
    *   return "Network data"
    * })
@@ -9441,9 +9521,11 @@ export const when: {
  * @example
  * ```ts
  * // Title: Handling Both Success and Failure Cases
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
  *
- * const success: Effect.Effect<number, Error> = Effect.succeed(42)
+ * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
  *
  * const program1 = Effect.match(success, {
  *   onFailure: (error) => `failure: ${error.message}`,
@@ -9454,8 +9536,8 @@ export const when: {
  * Effect.runPromise(program1).then(console.log)
  * // Output: "success: 42"
  *
- * const failure: Effect.Effect<number, Error> = Effect.fail(
- *   new Error("Uh oh!")
+ * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+ *   new ExampleError({ message: "Uh oh!" })
  * )
  *
  * const program2 = Effect.match(failure, {
@@ -9497,9 +9579,11 @@ export const match: {
    * @example
    * ```ts
    * // Title: Handling Both Success and Failure Cases
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
    *
-   * const success: Effect.Effect<number, Error> = Effect.succeed(42)
+   * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
+   *
+   * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
    *
    * const program1 = Effect.match(success, {
    *   onFailure: (error) => `failure: ${error.message}`,
@@ -9510,8 +9594,8 @@ export const match: {
    * Effect.runPromise(program1).then(console.log)
    * // Output: "success: 42"
    *
-   * const failure: Effect.Effect<number, Error> = Effect.fail(
-   *   new Error("Uh oh!")
+   * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+   *   new ExampleError({ message: "Uh oh!" })
    * )
    *
    * const program2 = Effect.match(failure, {
@@ -9558,9 +9642,11 @@ export const match: {
    * @example
    * ```ts
    * // Title: Handling Both Success and Failure Cases
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
    *
-   * const success: Effect.Effect<number, Error> = Effect.succeed(42)
+   * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
    *
    * const program1 = Effect.match(success, {
    *   onFailure: (error) => `failure: ${error.message}`,
@@ -9571,8 +9657,8 @@ export const match: {
    * Effect.runPromise(program1).then(console.log)
    * // Output: "success: 42"
    *
-   * const failure: Effect.Effect<number, Error> = Effect.fail(
-   *   new Error("Uh oh!")
+   * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+   *   new ExampleError({ message: "Uh oh!" })
    * )
    *
    * const program2 = Effect.match(failure, {
@@ -10002,9 +10088,11 @@ export const matchCauseEffectEager: {
  *
  * @example
  * ```ts
- * import { Cause, Console, Effect, Result } from "effect"
+ * import { Cause, Console, Data, Effect, Result } from "effect"
  *
- * const task = Effect.fail(new Error("Task failed"))
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+ *
+ * const task = Effect.fail(new TaskError({ message: "Task failed" }))
  *
  * const program = Effect.matchCauseEffect(task, {
  *   onFailure: (cause) =>
@@ -10054,9 +10142,11 @@ export const matchCauseEffect: {
    *
    * @example
    * ```ts
-   * import { Cause, Console, Effect, Result } from "effect"
+   * import { Cause, Console, Data, Effect, Result } from "effect"
+   *
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
    *
-   * const task = Effect.fail(new Error("Task failed"))
+   * const task = Effect.fail(new TaskError({ message: "Task failed" }))
    *
    * const program = Effect.matchCauseEffect(task, {
    *   onFailure: (cause) =>
@@ -10111,9 +10201,11 @@ export const matchCauseEffect: {
    *
    * @example
    * ```ts
-   * import { Cause, Console, Effect, Result } from "effect"
+   * import { Cause, Console, Data, Effect, Result } from "effect"
    *
-   * const task = Effect.fail(new Error("Task failed"))
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+   *
+   * const task = Effect.fail(new TaskError({ message: "Task failed" }))
    *
    * const program = Effect.matchCauseEffect(task, {
    *   onFailure: (cause) =>
@@ -10177,11 +10269,13 @@ export const matchCauseEffect: {
  * @example
  * ```ts
  * // Title: Handling Both Success and Failure Cases with Side Effects
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
  *
- * const success: Effect.Effect<number, Error> = Effect.succeed(42)
- * const failure: Effect.Effect<number, Error> = Effect.fail(
- *   new Error("Uh oh!")
+ * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
+ *
+ * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
+ * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+ *   new ExampleError({ message: "Uh oh!" })
  * )
  *
  * const program1 = Effect.matchEffect(success, {
@@ -10237,11 +10331,13 @@ export const matchEffect: {
    * @example
    * ```ts
    * // Title: Handling Both Success and Failure Cases with Side Effects
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
    *
-   * const success: Effect.Effect<number, Error> = Effect.succeed(42)
-   * const failure: Effect.Effect<number, Error> = Effect.fail(
-   *   new Error("Uh oh!")
+   * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
+   * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+   *   new ExampleError({ message: "Uh oh!" })
    * )
    *
    * const program1 = Effect.matchEffect(success, {
@@ -10302,11 +10398,13 @@ export const matchEffect: {
    * @example
    * ```ts
    * // Title: Handling Both Success and Failure Cases with Side Effects
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
    *
-   * const success: Effect.Effect<number, Error> = Effect.succeed(42)
-   * const failure: Effect.Effect<number, Error> = Effect.fail(
-   *   new Error("Uh oh!")
+   * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
+   *
+   * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
+   * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+   *   new ExampleError({ message: "Uh oh!" })
    * )
    *
    * const program1 = Effect.matchEffect(success, {
@@ -12150,9 +12248,11 @@ export const ensuring: {
  *
  * @example
  * ```ts
- * import { Cause, Console, Effect } from "effect"
+ * import { Cause, Data, Console, Effect } from "effect"
  *
- * const task = Effect.fail(new Error("Something went wrong"))
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+ *
+ * const task = Effect.fail(new TaskError({ message: "Something went wrong" }))
  *
  * const program = Effect.onError(
  *   task,
@@ -12161,8 +12261,8 @@ export const ensuring: {
  *
  * Effect.runPromise(program).catch(console.error)
  * // Output:
- * // Cleanup on error: Error: Something went wrong
- * // Error: Something went wrong
+ * // Cleanup on error: TaskError: Something went wrong
+ * // TaskError: Something went wrong
  * ```
  *
  * @since 2.0.0
@@ -12175,9 +12275,11 @@ export const onError: {
    *
    * @example
    * ```ts
-   * import { Cause, Console, Effect } from "effect"
+   * import { Cause, Data, Console, Effect } from "effect"
    *
-   * const task = Effect.fail(new Error("Something went wrong"))
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+   *
+   * const task = Effect.fail(new TaskError({ message: "Something went wrong" }))
    *
    * const program = Effect.onError(
    *   task,
@@ -12186,8 +12288,8 @@ export const onError: {
    *
    * Effect.runPromise(program).catch(console.error)
    * // Output:
-   * // Cleanup on error: Error: Something went wrong
-   * // Error: Something went wrong
+   * // Cleanup on error: TaskError: Something went wrong
+   * // TaskError: Something went wrong
    * ```
    *
    * @since 2.0.0
@@ -12200,9 +12302,11 @@ export const onError: {
    *
    * @example
    * ```ts
-   * import { Cause, Console, Effect } from "effect"
+   * import { Cause, Data, Console, Effect } from "effect"
    *
-   * const task = Effect.fail(new Error("Something went wrong"))
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+   *
+   * const task = Effect.fail(new TaskError({ message: "Something went wrong" }))
    *
    * const program = Effect.onError(
    *   task,
@@ -12211,8 +12315,8 @@ export const onError: {
    *
    * Effect.runPromise(program).catch(console.error)
    * // Output:
-   * // Cleanup on error: Error: Something went wrong
-   * // Error: Something went wrong
+   * // Cleanup on error: TaskError: Something went wrong
+   * // TaskError: Something went wrong
    * ```
    *
    * @since 2.0.0
@@ -15429,7 +15533,7 @@ export const withParentSpan: {
  * )
  *
  * const program = Effect.gen(function*() {
- *   const name = yield* Effect.request(GetUser({ id: 1 }), Effect.succeed(resolver))
+ *   const name = yield* Effect.request(GetUser({ id: 1 }), resolver)
  *   yield* Console.log(name)
  * })
  * ```
@@ -15464,7 +15568,7 @@ export const request: {
    * )
    *
    * const program = Effect.gen(function*() {
-   *   const name = yield* Effect.request(GetUser({ id: 1 }), Effect.succeed(resolver))
+   *   const name = yield* Effect.request(GetUser({ id: 1 }), resolver)
    *   yield* Console.log(name)
    * })
    * ```
@@ -15499,7 +15603,7 @@ export const request: {
    * )
    *
    * const program = Effect.gen(function*() {
-   *   const name = yield* Effect.request(GetUser({ id: 1 }), Effect.succeed(resolver))
+   *   const name = yield* Effect.request(GetUser({ id: 1 }), resolver)
    *   yield* Console.log(name)
    * })
    * ```
@@ -21730,18 +21834,20 @@ export const trackSuccesses: {
  *
  * @example
  * ```ts
- * import { Effect, Metric } from "effect"
+ * import { Data, Effect, Metric } from "effect"
+ *
+ * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
  *
  * // Track error types using frequency metric
  * const errorTypeFrequency = Metric.frequency("error_types")
  *
- * const program = Effect.fail(new Error("Connection failed")).pipe(
- *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+ * const program = Effect.fail(new ConnectionFailedError()).pipe(
+ *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
  * )
  *
  * Effect.runPromiseExit(program).then(() =>
  *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
- *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+ *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
  * )
  * ```
  *
@@ -21776,18 +21882,20 @@ export const trackErrors: {
    *
    * @example
    * ```ts
-   * import { Effect, Metric } from "effect"
+   * import { Data, Effect, Metric } from "effect"
+   *
+   * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
    *
    * // Track error types using frequency metric
    * const errorTypeFrequency = Metric.frequency("error_types")
    *
-   * const program = Effect.fail(new Error("Connection failed")).pipe(
-   *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+   * const program = Effect.fail(new ConnectionFailedError()).pipe(
+   *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
    * )
    *
    * Effect.runPromiseExit(program).then(() =>
    *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-   *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+   *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
    * )
    * ```
    *
@@ -21822,18 +21930,20 @@ export const trackErrors: {
    *
    * @example
    * ```ts
-   * import { Effect, Metric } from "effect"
+   * import { Data, Effect, Metric } from "effect"
+   *
+   * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
    *
    * // Track error types using frequency metric
    * const errorTypeFrequency = Metric.frequency("error_types")
    *
-   * const program = Effect.fail(new Error("Connection failed")).pipe(
-   *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+   * const program = Effect.fail(new ConnectionFailedError()).pipe(
+   *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
    * )
    *
    * Effect.runPromiseExit(program).then(() =>
    *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-   *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+   *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
    * )
    * ```
    *
@@ -21868,18 +21978,20 @@ export const trackErrors: {
    *
    * @example
    * ```ts
-   * import { Effect, Metric } from "effect"
+   * import { Data, Effect, Metric } from "effect"
+   *
+   * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
    *
    * // Track error types using frequency metric
    * const errorTypeFrequency = Metric.frequency("error_types")
    *
-   * const program = Effect.fail(new Error("Connection failed")).pipe(
-   *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+   * const program = Effect.fail(new ConnectionFailedError()).pipe(
+   *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
    * )
    *
    * Effect.runPromiseExit(program).then(() =>
    *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-   *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+   *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
    * )
    * ```
    *
@@ -21918,18 +22030,20 @@ export const trackErrors: {
    *
    * @example
    * ```ts
-   * import { Effect, Metric } from "effect"
+   * import { Data, Effect, Metric } from "effect"
+   *
+   * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
    *
    * // Track error types using frequency metric
    * const errorTypeFrequency = Metric.frequency("error_types")
    *
-   * const program = Effect.fail(new Error("Connection failed")).pipe(
-   *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+   * const program = Effect.fail(new ConnectionFailedError()).pipe(
+   *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
    * )
    *
    * Effect.runPromiseExit(program).then(() =>
    *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-   *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+   *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
    * )
    * ```
    *
@@ -23219,18 +23333,20 @@ export const satisfiesSuccessType = <A>() => <A2 extends A, E, R>(effect: Effect
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class ValidationError extends Data.TaggedError("ValidationError")<{}> {}
  *
- * // Define a constraint that the error type must be an Error
- * const satisfiesError = Effect.satisfiesErrorType<Error>()
+ * // Define a constraint that the error type must be a ValidationError
+ * const satisfiesError = Effect.satisfiesErrorType<ValidationError>()
  *
- * // This works - Effect<number, TypeError, never> extends Effect<number, Error, never>
- * const validEffect = satisfiesError(Effect.fail(new TypeError("Invalid type")))
+ * // This works - Effect<number, ValidationError, never> extends the constrained type
+ * const validEffect = satisfiesError(Effect.fail(new ValidationError()))
  *
  * // This would cause a TypeScript compilation error:
  * // const invalidEffect = satisfiesError(Effect.fail("string error"))
  * //                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
- * // Type 'string' is not assignable to type 'Error'
+ * // Type 'string' is not assignable to type 'ValidationError'
  * ```
  *
  * @since 4.0.0