functype 0.18.0 → 0.20.0

package/dist/index-Bnjlo4cT.d.ts

@@ -0,0 +1,3575 @@
+import { t as Brand } from "./Brand-B-0nKo7I.js";
+import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple, u as Type } from "./Tuple-CKxIyX7l.js";
+
+//#region src/do/protocol.d.ts
+
+/**
+ * Protocol definitions for Do-notation
+ * Separated from main Do module to avoid circular dependencies
+ */
+/**
+ * Result type for Do-notation unwrapping
+ * Indicates whether unwrapping succeeded and provides the value or error
+ */
+type DoResult<T$1> = {
+  ok: true;
+  value: T$1;
+} | {
+  ok: false;
+  empty: true;
+} | {
+  ok: false;
+  empty: false;
+  error: unknown;
+};
+/**
+ * Interface for types that support Do-notation
+ * Implementing this interface allows a type to be yielded in Do-comprehensions
+ *
+ * The doUnwrap method should return a DoResult indicating success/failure
+ * and the contained value or error information
+ */
+interface Doable<T$1> {
+  doUnwrap(): DoResult<T$1>;
+}
+//#endregion
+//#region src/extractable/Extractable.d.ts
+/**
+ * Interface for operations that can fail with exceptions.
+ * These methods should be used with care as they can throw at runtime.
+ *
+ * @interface Unsafe
+ * @template T The type of value that can be extracted
+ */
+interface Unsafe<T$1 extends Type> {
+  /**
+   * Extract the value or throw an error
+   * @param error Optional custom error to throw. If not provided, uses type-appropriate default error
+   * @throws {Error} The specified error, container's error, or a sensible default
+   * @returns The contained value
+   */
+  orThrow(error?: Error): T$1;
+}
+/**
+ * Extractable type class for data structures that can extract their values
+ * with various fallback strategies.
+ *
+ * This interface is implemented by Option, Either, and other types that
+ * wrap values and need both safe and fallible extraction methods.
+ *
+ * Extends Unsafe to provide exception-throwing operations alongside safe alternatives.
+ */
+interface Extractable<T$1 extends Type> extends Unsafe<T$1> {
+  /**
+   * Returns the contained value or a default value
+   * @param defaultValue - The value to return if extraction fails
+   * @returns The contained value or defaultValue
+   */
+  orElse(defaultValue: T$1): T$1;
+  /**
+   * Returns this container if it has a value, otherwise returns the alternative container
+   * @param alternative - The alternative container
+   * @returns This container or the alternative
+   */
+  or(alternative: Extractable<T$1>): Extractable<T$1>;
+  /**
+   * Returns the contained value or null
+   * @returns The contained value or null
+   */
+  orNull(): T$1 | null;
+  /**
+   * Returns the contained value or undefined
+   * @returns The contained value or undefined
+   */
+  orUndefined(): T$1 | undefined;
+}
+/**
+ * Type guard to check if a value implements Extractable
+ */
+declare function isExtractable<T$1 extends Type>(value: unknown): value is Extractable<T$1>;
+//#endregion
+//#region src/list/LazyList.d.ts
+/**
+ * LazyList provides lazy evaluation for list operations.
+ * Operations are deferred until the list is materialized.
+ *
+ * @example
+ * // Basic lazy evaluation
+ * const result = LazyList([1, 2, 3, 4, 5])
+ *   .map(x => x * 2)
+ *   .filter(x => x > 5)
+ *   .toArray() // [6, 8, 10]
+ *
+ * @example
+ * // Infinite sequences with take
+ * const fibonacci = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
+ *   .map(([a]) => a)
+ *   .take(10)
+ *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+ */
+interface LazyList<A extends Type> extends Foldable<A>, Pipe<LazyList<A>>, Serializable<LazyList<A>>, Typeable<"LazyList"> {
+  [Symbol.iterator](): Iterator<A>;
+  map<B extends Type>(f: (a: A) => B): LazyList<B>;
+  flatMap<B extends Type>(f: (a: A) => LazyList<B>): LazyList<B>;
+  filter(predicate: (a: A) => boolean): LazyList<A>;
+  take(n: number): LazyList<A>;
+  drop(n: number): LazyList<A>;
+  takeWhile(predicate: (a: A) => boolean): LazyList<A>;
+  dropWhile(predicate: (a: A) => boolean): LazyList<A>;
+  concat(other: LazyList<A>): LazyList<A>;
+  zip<B extends Type>(other: LazyList<B>): LazyList<[A, B]>;
+  toList(): List<A>;
+  toArray(): A[];
+  forEach(f: (a: A) => void): void;
+  reduce<B extends Type>(f: (acc: B, a: A) => B, initial: B): B;
+  find(predicate: (a: A) => boolean): Option<A>;
+  some(predicate: (a: A) => boolean): boolean;
+  every(predicate: (a: A) => boolean): boolean;
+  count(): number;
+  first(): Option<A>;
+  last(): Option<A>;
+  toString(): string;
+}
+/**
+ * Lazy list implementation for efficient deferred computation
+ * @example
+ * // Process large datasets efficiently
+ * const result = LazyList.range(1, 1000000)
+ *   .filter(x => x % 2 === 0)
+ *   .map(x => x * x)
+ *   .take(5)
+ *   .toArray() // [4, 16, 36, 64, 100]
+ *
+ * @example
+ * // Infinite sequences
+ * const primes = LazyList.iterate(2, n => n + 1)
+ *   .filter(isPrime)
+ *   .take(10)
+ *   .toArray() // First 10 prime numbers
+ *
+ * @example
+ * // Combining operations
+ * const evens = LazyList.range(0, 100, 2)
+ * const odds = LazyList.range(1, 100, 2)
+ * const combined = evens.zip(odds)
+ *   .map(([e, o]) => e + o)
+ *   .take(5)
+ *   .toArray() // [1, 5, 9, 13, 17]
+ */
+declare const LazyList: (<A extends Type>(iterable: Iterable<A>) => LazyList<A>) & {
+  /**
+   * Create an empty LazyList
+   * @example
+   * const empty = LazyList.empty<number>()
+   * empty.toArray() // []
+   */
+  empty: <A extends Type>() => LazyList<A>;
+  /**
+   * Create a LazyList from a single value
+   * @example
+   * const single = LazyList.of(42)
+   *   .map(x => x * 2)
+   *   .toArray() // [84]
+   */
+  of: <A extends Type>(value: A) => LazyList<A>;
+  /**
+   * Create a LazyList from multiple values
+   */
+  from: <A extends Type>(...values: A[]) => LazyList<A>;
+  /**
+   * Create an infinite LazyList by repeatedly applying a function
+   * @example
+   * // Powers of 2
+   * const powers = LazyList.iterate(1, x => x * 2)
+   *   .take(10)
+   *   .toArray() // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+   *
+   * @example
+   * // Fibonacci sequence
+   * const fib = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
+   *   .map(([a]) => a)
+   *   .take(8)
+   *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13]
+   */
+  iterate: <A extends Type>(initial: A, f: (a: A) => A) => LazyList<A>;
+  /**
+   * Create an infinite LazyList by repeatedly calling a function
+   */
+  generate: <A extends Type>(f: () => A) => LazyList<A>;
+  /**
+   * Create a LazyList of numbers from start to end (exclusive)
+   * @example
+   * LazyList.range(1, 6).toArray() // [1, 2, 3, 4, 5]
+   * LazyList.range(0, 10, 2).toArray() // [0, 2, 4, 6, 8]
+   * LazyList.range(10, 0, -1).toArray() // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+   *
+   * @example
+   * // Sum of squares from 1 to 100
+   * const sum = LazyList.range(1, 101)
+   *   .map(x => x * x)
+   *   .reduce((a, b) => a + b, 0) // 338350
+   */
+  range: (start: number, end: number, step?: number) => LazyList<number>;
+  /**
+   * Create a LazyList that repeats a value n times (or infinitely if n is not provided)
+   */
+  repeat: <A extends Type>(value: A, n?: number) => LazyList<A>;
+  /**
+   * Create a LazyList that cycles through an iterable infinitely
+   */
+  cycle: <A extends Type>(iterable: Iterable<A>) => LazyList<A>;
+};
+//#endregion
+//#region src/typeclass/ContainerOps.d.ts
+/**
+ * Universal operations that work on any container (single-value or collection).
+ * These operations make sense for Option, Either, Try, List, Set, etc.
+ *
+ * @typeParam A - The type of value(s) in the container
+ */
+interface ContainerOps<A extends Type> {
+  /**
+   * Counts elements that satisfy the predicate.
+   * For single-value containers: returns 0 or 1
+   * For collections: returns the count of matching elements
+   */
+  count(p: (x: A) => boolean): number;
+  /**
+   * Finds the first element that satisfies the predicate.
+   * For single-value containers: returns Some(value) if predicate matches, None otherwise
+   * For collections: returns the first matching element wrapped in Option
+   */
+  find(p: (a: A) => boolean): Option<A>;
+  /**
+   * Tests whether any element satisfies the predicate.
+   * For single-value containers: tests the single value
+   * For collections: returns true if any element matches
+   */
+  exists(p: (a: A) => boolean): boolean;
+  /**
+   * Applies an effect function to each element.
+   * For single-value containers: applies to the value if present
+   * For collections: applies to each element
+   */
+  forEach(f: (a: A) => void): void;
+}
+/**
+ * Operations specific to collections (List, Set, etc.).
+ * These operations don't make sense for single-value containers.
+ *
+ * @typeParam A - The element type
+ * @typeParam Self - The collection type itself for proper return types
+ */
+interface CollectionOps<A extends Type, Self> {
+  /**
+   * Drops the first n elements from the collection.
+   */
+  drop(n: number): Self;
+  /**
+   * Drops the last n elements from the collection.
+   */
+  dropRight(n: number): Self;
+  /**
+   * Drops elements from the start while the predicate is true.
+   */
+  dropWhile(p: (a: A) => boolean): Self;
+  /**
+   * Flattens a collection of collections into a single collection.
+   */
+  flatten<B>(): Self;
+  /**
+   * Gets the first element of the collection.
+   */
+  get head(): A | undefined;
+  /**
+   * Gets the first element wrapped in Option.
+   */
+  get headOption(): Option<A>;
+  /**
+   * Converts the collection to an array.
+   */
+  toArray<B = A>(): B[];
+}
+//#endregion
+//#region src/typeclass/Functor.d.ts
+/**
+ * Functor type class - supports mapping over wrapped values
+ *
+ * Laws:
+ * - Identity: fa.map(x => x) ≡ fa
+ * - Composition: fa.map(f).map(g) ≡ fa.map(x => g(f(x)))
+ */
+interface Functor<A extends Type> {
+  map<B extends Type>(f: (value: A) => B): Functor<B>;
+}
+/**
+ * Applicative functor - supports applying wrapped functions to wrapped values
+ *
+ * Laws:
+ * - Identity: pure(x => x).ap(v) ≡ v
+ * - Composition: pure(compose).ap(u).ap(v).ap(w) ≡ u.ap(v.ap(w))
+ * - Homomorphism: pure(f).ap(pure(x)) ≡ pure(f(x))
+ * - Interchange: u.ap(pure(y)) ≡ pure(f => f(y)).ap(u)
+ */
+interface Applicative<A extends Type> extends Functor<A> {
+  ap<B extends Type>(ff: Applicative<(value: A) => B>): Applicative<B>;
+}
+/**
+ * Monad type class - supports flat mapping (chaining) operations
+ *
+ * Laws:
+ * - Left identity: pure(a).flatMap(f) ≡ f(a)
+ * - Right identity: m.flatMap(pure) ≡ m
+ * - Associativity: m.flatMap(f).flatMap(g) ≡ m.flatMap(x => f(x).flatMap(g))
+ */
+interface Monad<A extends Type> extends Applicative<A> {
+  flatMap<B extends Type>(f: (value: A) => Monad<B>): Monad<B>;
+}
+/**
+ * Async monad - supports asynchronous monadic operations
+ * Extends Monad so it has map, ap, and flatMap in addition to flatMapAsync
+ */
+interface AsyncMonad<A extends Type> extends Monad<A> {
+  flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<AsyncMonad<B>>): PromiseLike<AsyncMonad<B>>;
+}
+//#endregion
+//#region src/typeclass/Promisable.d.ts
+/**
+ * Promisable trait - supports conversion to Promise
+ *
+ * Represents containers or values that can be converted to Promise form.
+ * This enables integration with async/await patterns and Promise-based APIs
+ * while maintaining functional programming principles.
+ *
+ * @template A - The type of value contained within the Promise
+ *
+ * @example
+ * ```typescript
+ * const either: Either<string, number> = Right(42)
+ * const promise: Promise<number> = either.toPromise()
+ * // Promise resolves with 42
+ *
+ * const leftEither: Either<string, number> = Left("error")
+ * const failedPromise: Promise<number> = leftEither.toPromise()
+ * // Promise rejects with "error"
+ * ```
+ */
+interface Promisable<A extends Type> {
+  /**
+   * Converts this container to a Promise
+   *
+   * The behavior depends on the implementing container:
+   * - Success/Right/Some containers resolve with their value
+   * - Failure/Left/None containers reject with their error/default error
+   *
+   * @returns A Promise that resolves or rejects based on the container's state
+   */
+  toPromise(): Promise<A>;
+}
+//#endregion
+//#region src/try/Try.d.ts
+/**
+ * Possible types of Try instances
+ */
+type TypeNames = "Success" | "Failure";
+interface Try<T$1> extends FunctypeBase<T$1, TypeNames>, Extractable<T$1>, Pipe<T$1>, Promisable<T$1>, Doable<T$1>, Reshapeable<T$1> {
+  readonly _tag: TypeNames;
+  readonly error: Error | undefined;
+  isSuccess(): this is Try<T$1> & {
+    readonly _tag: "Success";
+    error: undefined;
+  };
+  isFailure(): this is Try<T$1> & {
+    readonly _tag: "Failure";
+    error: Error;
+  };
+  orElse: (defaultValue: T$1) => T$1;
+  orThrow: (error?: Error) => T$1;
+  or: (alternative: Try<T$1>) => Try<T$1>;
+  orNull: () => T$1 | null;
+  orUndefined: () => T$1 | undefined;
+  toOption: () => Option<T$1>;
+  toEither: <E extends Type>(leftValue: E) => Either<E, T$1>;
+  toList: () => List<T$1>;
+  toTry: () => Try<T$1>;
+  map: <U>(f: (value: T$1) => U) => Try<U>;
+  ap: <U>(ff: Try<(value: T$1) => U>) => Try<U>;
+  flatMap: <U>(f: (value: T$1) => Try<U>) => Try<U>;
+  flatMapAsync: <U>(f: (value: T$1) => Promise<Try<U>>) => Promise<Try<U>>;
+  /**
+   * Pattern matches over the Try, applying onFailure if Failure and onSuccess if Success
+   * @param onFailure - Function to apply if the Try is Failure
+   * @param onSuccess - Function to apply if the Try is Success
+   * @returns The result of applying the appropriate function
+   */
+  fold: <U extends Type>(onFailure: (error: Error) => U, onSuccess: (value: T$1) => U) => U;
+  toString: () => string;
+  /**
+   * Pattern matches over the Try, applying a handler function based on the variant
+   * @param patterns - Object with handler functions for Success and Failure variants
+   * @returns The result of applying the matching handler function
+   */
+  match<R$1>(patterns: {
+    Success: (value: T$1) => R$1;
+    Failure: (error: Error) => R$1;
+  }): R$1;
+  toValue(): {
+    _tag: TypeNames;
+    value: T$1 | Error;
+  };
+}
+declare const Try: (<T$1>(f: () => T$1) => Try<T$1>) & {
+  /**
+   * Type guard to check if a Try is Success
+   * @param tryValue - The Try to check
+   * @returns True if Try is Success
+   */
+  isSuccess: <T$1>(tryValue: Try<T$1>) => tryValue is Try<T$1> & {
+    readonly _tag: "Success";
+    error: undefined;
+  };
+  /**
+   * Type guard to check if a Try is Failure
+   * @param tryValue - The Try to check
+   * @returns True if Try is Failure
+   */
+  isFailure: <T$1>(tryValue: Try<T$1>) => tryValue is Try<T$1> & {
+    readonly _tag: "Failure";
+    error: Error;
+  };
+  /**
+   * Creates a Try from JSON string
+   * @param json - The JSON string
+   * @returns Try instance
+   */
+  fromJSON: <T$1>(json: string) => Try<T$1>;
+  /**
+   * Creates a Try from YAML string
+   * @param yaml - The YAML string
+   * @returns Try instance
+   */
+  fromYAML: <T$1>(yaml: string) => Try<T$1>;
+  /**
+   * Creates a Try from binary string
+   * @param binary - The binary string
+   * @returns Try instance
+   */
+  fromBinary: <T$1>(binary: string) => Try<T$1>;
+};
+//#endregion
+//#region src/reshapeable/Reshapeable.d.ts
+/**
+ * Interface for types that can be reshaped (converted) between different monadic containers.
+ * Provides standard conversion methods to transform between Option, Either, List, and Try types.
+ *
+ * @typeParam T - The type of the value contained in the monad
+ *
+ * @example
+ * // Convert Option to Either
+ * const opt = Option(5)
+ * const either = opt.toEither("None value")  // Right(5)
+ *
+ * @example
+ * // Convert Either to Option
+ * const right = Right(10)
+ * const option = right.toOption()  // Some(10)
+ *
+ * @example
+ * // Convert List to Try
+ * const list = List([1, 2, 3])
+ * const tryVal = list.toTry()  // Success(1) - uses first element
+ *
+ * @example
+ * // Use with Do comprehensions
+ * const result = Do(function* () {
+ *   const x = yield* $(Option(5))
+ *   const y = yield* $(Right<string, number>(10))
+ *   return x + y
+ * })
+ *
+ * // Convert to desired type for chaining
+ * const asOption = result.toOption()
+ * asOption.map(x => x * 2).orElse(0)
+ */
+interface Reshapeable<T$1 extends Type> {
+  /**
+   * Converts this monad to an Option.
+   *
+   * Conversion rules:
+   * - Option: returns self
+   * - Either: Right → Some, Left → None
+   * - List: non-empty → Some(head), empty → None
+   * - Try: Success → Some, Failure → None
+   *
+   * @returns An Option containing the value if present, None otherwise
+   */
+  toOption(): Option<T$1>;
+  /**
+   * Converts this monad to an Either.
+   *
+   * Conversion rules:
+   * - Option: Some → Right, None → Left(leftValue)
+   * - Either: returns self
+   * - List: non-empty → Right(head), empty → Left(leftValue)
+   * - Try: Success → Right, Failure → Left(error)
+   *
+   * @param leftValue - The value to use for the Left case when the source is empty/none/failure
+   * @returns An Either with the value as Right or the provided leftValue as Left
+   */
+  toEither<E extends Type>(leftValue: E): Either<E, T$1>;
+  /**
+   * Converts this monad to a List.
+   *
+   * Conversion rules:
+   * - Option: Some → List([value]), None → List([])
+   * - Either: Right → List([value]), Left → List([])
+   * - List: returns self
+   * - Try: Success → List([value]), Failure → List([])
+   *
+   * @returns A List containing the value(s) if present, empty List otherwise
+   */
+  toList(): List<T$1>;
+  /**
+   * Converts this monad to a Try.
+   *
+   * Conversion rules:
+   * - Option: Some → Success, None → Failure(Error("None"))
+   * - Either: Right → Success, Left → Failure(Error(leftValue))
+   * - List: non-empty → Success(head), empty → Failure(Error("Empty list"))
+   * - Try: returns self
+   *
+   * @returns A Try containing Success with the value or Failure with an appropriate error
+   */
+  toTry(): Try<T$1>;
+}
+//#endregion
+//#region src/branded/ValidatedBrand.d.ts
+type ValidatedBrand<K$1 extends string, T$1> = Brand<K$1, T$1> & {
+  readonly __validated: true;
+};
+interface ValidatedBrandCompanion<K$1 extends string, T$1> {
+  readonly brand: K$1;
+  readonly validate: (value: T$1) => boolean;
+  readonly of: (value: T$1) => Option<ValidatedBrand<K$1, T$1>>;
+  readonly from: (value: T$1) => Either<string, ValidatedBrand<K$1, T$1>>;
+  readonly unsafeOf: (value: T$1) => ValidatedBrand<K$1, T$1>;
+  readonly is: (value: unknown) => value is ValidatedBrand<K$1, T$1>;
+  readonly unwrap: (branded: Brand<K$1, T$1>) => T$1;
+  readonly refine: <K2 extends string>(brand: K2, validate: (value: Brand<K$1, T$1>) => boolean) => ValidatedBrandCompanion<K2, Brand<K$1, T$1>>;
+}
+/**
+ * Create a validated brand with runtime validation
+ * @example
+ * const Email = ValidatedBrand("Email", (s: string) => /^[^@]+@[^@]+\.[^@]+$/.test(s))
+ * const email = Email.of("user@example.com") // Some(Brand<"Email", string>)
+ *
+ * @example
+ * // With Either for error messages
+ * const Port = ValidatedBrand("Port", (n: number) => n >= 1 && n <= 65535)
+ * const result = Port.from(8080) // Right(Brand<"Port", number>)
+ * const error = Port.from(70000) // Left("Invalid Port: validation failed")
+ *
+ * @example
+ * // Type guard usage
+ * const value: unknown = "test@example.com"
+ * if (Email.is(value)) {
+ *   // value is Brand<"Email", string>
+ * }
+ *
+ * @example
+ * // Best Practice: Use same brand name for seamless conversion
+ * // ValidatedBrand extends Brand, so when using the same brand name,
+ * // no casting is needed for conversion
+ * const ValidatedUserId = ValidatedBrand("UserId", (s: string) => s.length > 0)
+ * type ValidatedUserId = ReturnType<typeof ValidatedUserId.of> extends Option<infer T> ? T : never
+ * type UserId = Brand<"UserId", string>
+ *
+ * const toSimpleUserId = (id: ValidatedUserId): UserId => id // No cast needed!
+ *
+ * // Avoid different brand names which require casting:
+ * // ❌ ValidatedBrand("ValidatedUserId", ...) + Brand<"UserId", string>
+ * // ✅ ValidatedBrand("UserId", ...) + Brand<"UserId", string>
+ */
+declare function ValidatedBrand<K$1 extends string, T$1>(brand: K$1, validate: (value: T$1) => boolean): ValidatedBrandCompanion<K$1, T$1>;
+/**
+ * Positive number brand (> 0)
+ * @example
+ * const price = PositiveNumber.of(19.99) // Some(Brand<"PositiveNumber", number>)
+ * const invalid = PositiveNumber.of(-5) // None
+ * const checked = PositiveNumber.from(0) // Left("Invalid PositiveNumber: validation failed")
+ */
+declare const PositiveNumber: ValidatedBrandCompanion<"PositiveNumber", number>;
+declare const NonNegativeNumber: ValidatedBrandCompanion<"NonNegativeNumber", number>;
+declare const IntegerNumber: ValidatedBrandCompanion<"IntegerNumber", number>;
+declare const PositiveInteger: ValidatedBrandCompanion<"PositiveInteger", Brand<"PositiveNumber", number>>;
+/**
+ * Non-empty string brand
+ * @example
+ * const name = NonEmptyString.of("John") // Some(Brand<"NonEmptyString", string>)
+ * const empty = NonEmptyString.of("") // None
+ */
+declare const NonEmptyString: ValidatedBrandCompanion<"NonEmptyString", string>;
+/**
+ * Email address brand with basic validation
+ * @example
+ * const email = EmailAddress.of("user@example.com") // Some(Brand<"EmailAddress", string>)
+ * const invalid = EmailAddress.of("not-an-email") // None
+ *
+ * @example
+ * // Using with forms
+ * const processEmail = (input: string) => {
+ *   return EmailAddress.from(input)
+ *     .map(email => sendWelcomeEmail(email))
+ *     .orElse("Invalid email address")
+ * }
+ */
+declare const EmailAddress: ValidatedBrandCompanion<"EmailAddress", string>;
+declare const UrlString: ValidatedBrandCompanion<"UrlString", string>;
+declare const UUID: ValidatedBrandCompanion<"UUID", string>;
+declare const ISO8601Date: ValidatedBrandCompanion<"ISO8601Date", string>;
+/**
+ * Create a number brand with min/max bounds
+ * @example
+ * const Percentage = BoundedNumber("Percentage", 0, 100)
+ * const valid = Percentage.of(75) // Some(Brand<"Percentage", number>)
+ * const invalid = Percentage.of(150) // None
+ *
+ * @example
+ * const Port = BoundedNumber("Port", 1, 65535)
+ * const httpPort = Port.unsafeOf(80) // Brand<"Port", number>
+ * // Port.unsafeOf(70000) // throws Error
+ */
+declare function BoundedNumber(brand: string, min: number, max: number): ValidatedBrandCompanion<string, number>;
+/**
+ * Create a string brand with length constraints
+ * @example
+ * const Username = BoundedString("Username", 3, 20)
+ * const valid = Username.of("johndoe") // Some(Brand<"Username", string>)
+ * const tooShort = Username.of("jo") // None
+ * const tooLong = Username.of("verylongusernamethatexceedslimit") // None
+ */
+declare function BoundedString(brand: string, minLength: number, maxLength: number): ValidatedBrandCompanion<string, string>;
+/**
+ * Create a string brand that matches a regex pattern
+ * @example
+ * const HexColor = PatternString("HexColor", /^#[0-9a-f]{6}$/i)
+ * const red = HexColor.of("#ff0000") // Some(Brand<"HexColor", string>)
+ * const invalid = HexColor.of("red") // None
+ *
+ * @example
+ * const PhoneNumber = PatternString("PhoneNumber", /^\+?[1-9]\d{1,14}$/)
+ * const phone = PhoneNumber.from("+1234567890")
+ *   .map(p => formatPhoneNumber(p))
+ *   .orElse("Invalid phone number")
+ */
+declare function PatternString(brand: string, pattern: RegExp): ValidatedBrandCompanion<string, string>;
+//#endregion
+//#region src/companion/Companion.d.ts
+/**
+ * Creates a function-object hybrid similar to Scala's companion objects.
+ * This utility allows creating TypeScript function objects with attached methods,
+ * mimicking Scala's class + companion object pattern without using classes.
+ *
+ * @param object The main function that will be invoked when the object is called
+ * @param companion Additional static methods to attach to the function
+ * @returns A function with the attached methods
+ *
+ * @example
+ * const greet = (name: string) => `Hello, ${name}!`;
+ * const methods = {
+ *   formal: (name: string) => `Good day, ${name}.`,
+ *   casual: (name: string) => `Hey ${name}!`
+ * };
+ * const Greeter = createCompanionObject(greet, methods);
+ *
+ * // Usage:
+ * Greeter("World"); // Hello, World!
+ * Greeter.formal("Sir"); // Good day, Sir.
+ * Greeter.casual("Friend"); // Hey Friend!
+ */
+declare function Companion<ObjectF extends object, CompanionF extends object>(object: ObjectF, companion: CompanionF): ObjectF & CompanionF;
+//#endregion
+//#region src/companion/CompanionTypes.d.ts
+/**
+ * Helper types for working with the Companion pattern
+ * @module CompanionTypes
+ */
+/**
+ * Extracts the companion methods type from a Companion object
+ * @typeParam T - The Companion type
+ * @example
+ * ```typescript
+ * type OptionCompanionMethods = CompanionMethods<typeof Option>
+ * // { from: ..., none: ..., fromJSON: ..., etc. }
+ * ```
+ */
+type CompanionMethods<T$1> = T$1 extends ((...args: never[]) => unknown) & infer C ? C : never;
+/**
+ * Extracts the instance type from a constructor function
+ * @typeParam T - The constructor function type
+ * @example
+ * ```typescript
+ * type OptionInstance = InstanceType<typeof Option>
+ * // Option<T>
+ * ```
+ */
+type InstanceType<T$1> = T$1 extends ((...args: infer Args) => infer R) ? R extends ((...args: unknown[]) => unknown) ? ReturnType<R> : R : never;
+/**
+ * Type guard to check if a value is a Companion object (has both constructor and companion methods)
+ * @param value - The value to check
+ * @returns True if value is a Companion object
+ */
+declare const isCompanion: (value: unknown) => value is ((...args: never[]) => unknown) & Record<string, unknown>;
+//#endregion
+//#region src/conditional/Cond.d.ts
+/**
+ * Conditional expression that enforces exhaustive returns without early returns.
+ * Similar to Scala's if/else expressions that always return a value.
+ *
+ * @example
+ * const discount = Cond.of<number>()
+ *   .when(isPremiumMember, 0.2)
+ *   .elseWhen(isRegularMember, 0.1)
+ *   .else(0)
+ *
+ * @example
+ * // Chaining multiple conditions
+ * const status = Cond.of<string>()
+ *   .when(response.status >= 500, "Server Error")
+ *   .elseWhen(response.status >= 400, "Client Error")
+ *   .elseWhen(response.status >= 200, "Success")
+ *   .else("Unknown")
+ */
+type Cond<T$1 extends Type> = {
+  /**
+   * Add an if condition
+   */
+  when: (condition: boolean, value: T$1 | (() => T$1)) => Cond<T$1>;
+  /**
+   * Add an else-if condition
+   */
+  elseWhen: (condition: boolean, value: T$1 | (() => T$1)) => Cond<T$1>;
+  /**
+   * Terminal else clause - required to get the result
+   */
+  else: (value: T$1 | (() => T$1)) => T$1;
+  /**
+   * Get the result if a condition was met, throws if no condition met
+   */
+  orThrow: () => T$1;
+};
+/** @internal */
+type LazyCondChain<T$1> = {
+  when: (condition: () => boolean, value: () => T$1) => LazyCondChain<T$1>;
+  elseWhen: (condition: () => boolean, value: () => T$1) => LazyCondChain<T$1>;
+  else: (value: () => T$1) => T$1;
+};
+/**
+ * Conditional expression builder for functional if/else chains
+ * @example
+ * // Basic usage
+ * const size = Cond.of<string>()
+ *   .when(value > 100, "large")
+ *   .elseWhen(value > 50, "medium")
+ *   .else("small")
+ *
+ * @example
+ * // Pattern matching
+ * const message = Cond.match(errorCode)({
+ *   404: "Not Found",
+ *   500: "Server Error",
+ *   200: "OK"
+ * })
+ *
+ * @example
+ * // Lazy evaluation
+ * const result = Cond.lazy<string>()
+ *   .when(() => checkCondition1(), () => "Result 1")
+ *   .when(() => checkCondition2(), () => "Result 2")
+ *   .else(() => "Default")
+ */
+declare const Cond: (<T$1 extends Type>() => Cond<T$1>) & {
+  /**
+   * Create a conditional expression that must end with else
+   * @example
+   * const x = 7
+   * const result = Cond.of<string>()
+   *   .when(x > 10, "large")
+   *   .elseWhen(x > 5, "medium")
+   *   .else("small")
+   * // result = "medium"
+   *
+   * @example
+   * // With lazy evaluation
+   * const discount = Cond.of<number>()
+   *   .when(isPremium, () => calculatePremiumDiscount())
+   *   .when(isLoyal, () => calculateLoyaltyDiscount())
+   *   .else(0)
+   */
+  of: <T$1 extends Type>() => Cond<T$1>;
+  /**
+   * Pattern matching helper that ensures exhaustiveness
+   * @example
+   * type Status = "pending" | "success" | "error"
+   * const status: Status = "success"
+   * const result = Cond.match(status)({
+   *   "pending": "Waiting...",
+   *   "success": "Done!",
+   *   "error": "Failed!"
+   * })
+   * // result = "Done!"
+   *
+   * @example
+   * // With function values
+   * const action = "compute"
+   * const result = Cond.match(action)({
+   *   "compute": () => expensiveComputation(),
+   *   "cache": () => getCachedValue(),
+   *   "skip": () => defaultValue
+   * })
+   */
+  match: <T$1 extends string | number | symbol>(value: T$1) => <R$1 extends Type>(cases: Record<T$1, R$1 | (() => R$1)>) => R$1;
+  /**
+   * Create a lazy conditional that defers evaluation
+   * @example
+   * // Only evaluates conditions and values when needed
+   * const getMessage = Cond.lazy<string>()
+   *   .when(() => isError(), () => computeErrorMessage())
+   *   .when(() => isWarning(), () => computeWarningMessage())
+   *   .else(() => "Success")
+   *
+   * @example
+   * // Complex conditional with expensive checks
+   * const result = Cond.lazy<Action>()
+   *   .when(
+   *     () => user.role === "admin" && checkAdminPermissions(),
+   *     () => ({ type: "admin", permissions: loadAdminPermissions() })
+   *   )
+   *   .when(
+   *     () => user.role === "user" && user.isActive,
+   *     () => ({ type: "user", permissions: loadUserPermissions() })
+   *   )
+   *   .else(() => ({ type: "guest", permissions: [] }))
+   */
+  lazy: <T$1 extends Type>() => LazyCondChain<T$1>;
+};
+//#endregion
+//#region src/conditional/Match.d.ts
+/**
+ * Type-level utilities for exhaustiveness checking
+ * @internal
+ */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/** @internal */
+type IsUnion<T$1> = [T$1] extends [UnionToIntersection<T$1>] ? false : true;
+/** @internal */
+type RequireExhaustive<T$1, Cases> = IsUnion<T$1> extends true ? (keyof Cases extends T$1 ? (T$1 extends keyof Cases ? Cases : never) : never) : Cases;
+/**
+ * Pattern types for nested matching
+ * @internal
+ */
+type Pattern<T$1> = T$1 | { [K in keyof T$1]?: Pattern<T$1[K]> } | ((value: T$1) => boolean) | {
+  _: (value: T$1) => boolean;
+};
+/**
+ * Extract result from pattern
+ * @internal
+ */
+type PatternResult<T$1, R$1> = R$1 | ((matched: T$1) => R$1);
+/**
+ * Pattern matching construct similar to Scala's match expressions.
+ * Supports exhaustive matching, nested patterns, and guards.
+ *
+ * @example
+ * // Basic pattern matching
+ * const result = Match(value)
+ *   .case(x => x > 100, "large")
+ *   .case(x => x > 50, "medium")
+ *   .default("small")
+ *
+ * @example
+ * // Matching exact values
+ * const message = Match(status)
+ *   .caseValue("pending", "Please wait...")
+ *   .caseValue("success", "Completed!")
+ *   .caseValue("error", "Failed")
+ *   .default("Unknown")
+ *
+ * @example
+ * // Nested pattern matching
+ * const user = { name: "John", age: 30, role: "admin" }
+ * const msg = Match(user)
+ *   .case({ role: "admin", age: n => n >= 18 }, "Adult admin")
+ *   .case({ role: "user" }, u => `User: ${u.name}`)
+ *   .default("Guest")
+ */
+type Match<T$1 extends Type, R$1 extends Type> = {
+  /**
+   * Match against a pattern (value, nested object, or predicate)
+   */
+  case: (pattern: Pattern<T$1>, result: PatternResult<T$1, R$1>) => Match<T$1, R$1>;
+  /**
+   * Add a case that matches a specific value (backward compatibility)
+   */
+  caseValue: (match: T$1, result: R$1 | (() => R$1)) => Match<T$1, R$1>;
+  /**
+   * Add a case that matches multiple values (backward compatibility)
+   */
+  caseValues: (matches: T$1[], result: R$1 | (() => R$1)) => Match<T$1, R$1>;
+  /**
+   * Match with a guard function (alias for readability)
+   */
+  when: (guard: (value: T$1) => boolean, result: PatternResult<T$1, R$1>) => Match<T$1, R$1>;
+  /**
+   * Match multiple patterns (OR operation)
+   */
+  caseAny: (patterns: Pattern<T$1>[], result: PatternResult<T$1, R$1>) => Match<T$1, R$1>;
+  /**
+   * Default case - makes match non-exhaustive
+   */
+  default: (result: PatternResult<T$1, R$1>) => R$1;
+  /**
+   * Force exhaustive matching (compile-time check for union types)
+   */
+  exhaustive: () => R$1;
+  /**
+   * Get result if matched, throws if no match
+   */
+  orThrow: (errorMessage?: string) => R$1;
+  /**
+   * Get result wrapped in Option
+   */
+  toOption: () => Option<R$1>;
+};
+/**
+ * Pattern matching utility for type-safe conditional logic with exhaustiveness checking,
+ * nested patterns, and guard support
+ *
+ * @example
+ * // Basic pattern matching
+ * const result = Match(value)
+ *   .case(x => x > 0, "positive")
+ *   .case(x => x < 0, "negative")
+ *   .default("zero")
+ *
+ * @example
+ * // Exhaustive matching for union types
+ * type Color = "red" | "green" | "blue"
+ * const hex = Match.exhaustive<Color, string>({
+ *   red: "#FF0000",
+ *   green: "#00FF00",
+ *   blue: "#0000FF"
+ * })(color)
+ *
+ * @example
+ * // Nested pattern matching
+ * type User = { name: string; age: number; role: "admin" | "user" }
+ * const user: User = { name: "John", age: 30, role: "admin" }
+ *
+ * const message = Match<User, string>(user)
+ *   .case({ role: "admin", age: (n) => n >= 18 }, "Adult admin")
+ *   .case({ role: "user" }, u => `User: ${u.name}`)
+ *   .default("Unknown")
+ *
+ * @example
+ * // Using exhaustive() method
+ * type Status = "idle" | "loading" | "success" | "error"
+ * const result = Match<Status, string>("success")
+ *   .case("idle", "Waiting...")
+ *   .case("loading", "Loading...")
+ *   .case("success", "Done!")
+ *   .case("error", "Failed!")
+ *   .exhaustive()
+ */
+declare const Match: (<T$1 extends Type, R$1 extends Type>(value: T$1) => Match<T$1, R$1>) & {
+  /**
+   * Create a type-safe exhaustive match for union types
+   * @example
+   * type Status = "pending" | "success" | "error"
+   * const status: Status = "success"
+   * const result = Match.exhaustive<Status, string>({
+   *   pending: "Waiting...",
+   *   success: "Done!",
+   *   error: "Failed!"
+   * })(status)
+   * // result = "Done!"
+   *
+   * @example
+   * // For function values, wrap in object to prevent execution
+   * type Operation = "add" | "subtract" | "multiply"
+   * const ops = Match.exhaustive<Operation, { fn: (a: number, b: number) => number }>({
+   *   add: { fn: (a, b) => a + b },
+   *   subtract: { fn: (a, b) => a - b },
+   *   multiply: { fn: (a, b) => a * b }
+   * })
+   * const compute = ops("multiply").fn
+   * const result = compute(4, 5) // 20
+   */
+  exhaustive: <T$1 extends string | number | symbol, R$1 extends Type>(cases: RequireExhaustive<T$1, Record<T$1, R$1>>) => (value: T$1) => R$1;
+  /**
+   * Create a partial match that requires a default
+   * @example
+   * const httpCode = 404
+   * const message = Match.partial<number, string>({
+   *   200: "OK",
+   *   201: "Created",
+   *   404: "Not Found",
+   *   500: "Server Error"
+   * }).withDefault("Unknown Status")(httpCode)
+   * // message = "Not Found"
+   *
+   * @example
+   * // With function default
+   * const getMessage = Match.partial<number, string>({
+   *   0: "Zero",
+   *   1: "One",
+   *   2: "Two"
+   * }).withDefault((n) => `Number: ${n}`)
+   * getMessage(5) // "Number: 5"
+   */
+  partial: <T$1 extends string | number | symbol, R$1 extends Type>(cases: Partial<Record<T$1, R$1 | ((value: T$1) => R$1)>>) => {
+    withDefault: (defaultValue: R$1 | ((value: T$1) => R$1)) => (value: T$1) => R$1;
+  };
+  /**
+   * Pattern match with guards
+   * @example
+   * const score = 85
+   * const grade = Match.withGuards<number, string>([
+   *   [n => n >= 90, "A"],
+   *   [n => n >= 80, "B"],
+   *   [n => n >= 70, "C"],
+   *   [n => n >= 60, "D"]
+   * ]).withDefault("F")(score)
+   * // grade = "B"
+   *
+   * @example
+   * // With function results for custom messages
+   * const age = 25
+   * const category = Match.withGuards<number, string>([
+   *   [n => n < 13, n => `Child (${n} years)`],
+   *   [n => n < 20, n => `Teenager (${n} years)`],
+   *   [n => n < 60, n => `Adult (${n} years)`],
+   *   [n => n >= 60, n => `Senior (${n} years)`]
+   * ]).withDefault("Unknown")(age)
+   * // category = "Adult (25 years)"
+   */
+  withGuards: <T$1 extends Type, R$1 extends Type>(guards: Array<[(value: T$1) => boolean, R$1 | ((value: T$1) => R$1)]>) => {
+    withDefault: (defaultValue: R$1 | ((value: T$1) => R$1)) => (value: T$1) => R$1;
+  };
+  /**
+   * Pattern matching for objects with specific structure
+   * @example
+   * type Event =
+   *   | { type: "click"; x: number; y: number }
+   *   | { type: "keypress"; key: string }
+   *   | { type: "hover"; element: string }
+   *
+   * const handler = Match.struct<Event, void>()
+   *   .case({ type: "click" }, (e) => console.log(`Click at ${e.x}, ${e.y}`))
+   *   .case({ type: "keypress", key: "Enter" }, () => console.log("Enter pressed"))
+   *   .case({ type: "hover" }, (e) => console.log(`Hovering over ${e.element}`))
+   *   .build()
+   */
+  struct: <T$1 extends Type, R$1 extends Type>() => {
+    case: (pattern: Pattern<T$1>, handler: (value: T$1) => R$1) => /*elided*/any;
+    build: () => (value: T$1) => R$1;
+  };
+  /**
+   * Create a pattern matcher with guards and nested patterns
+   * @example
+   * type User = {
+   *   name: string
+   *   age: number
+   *   permissions: string[]
+   * }
+   *
+   * const canAccess = Match.builder<User, boolean>()
+   *   .when(u => u.permissions.includes("admin"), true)
+   *   .case({ age: n => n >= 18, permissions: p => p.length > 0 }, true)
+   *   .default(false)
+   *   .build()
+   */
+  builder: <T$1 extends Type, R$1 extends Type>() => {
+    case: (pattern: Pattern<T$1>, result: PatternResult<T$1, R$1>) => /*elided*/any;
+    when: (guard: (value: T$1) => boolean, result: PatternResult<T$1, R$1>) => /*elided*/any;
+    default: (result: PatternResult<T$1, R$1>) => {
+      build: () => (value: T$1) => R$1;
+    };
+  };
+};
+//#endregion
+//#region src/core/base/Base.d.ts
+/**
+ * Base Object from which most other objects inherit
+ * Now includes automatic Do-notation support via doUnwrap method
+ * @param type - The type name for the object
+ * @param body - The implementation body
+ */
+declare function Base<T$1 extends Record<string, unknown>>(type: string, body: T$1): T$1 & {
+  toString(): string;
+  doUnwrap(): DoResult<unknown>;
+  _tag: string;
+};
+//#endregion
+//#region src/core/throwable/Throwable.d.ts
+/**
+ * The identifier name for Throwable type
+ */
+declare const NAME: "Throwable";
+/**
+ * @internal
+ */
+type ThrowableType = Error & Typeable<typeof NAME> & {
+  readonly data?: unknown;
+  readonly cause?: Error;
+  readonly taskInfo?: {
+    name: string;
+    description: string;
+  };
+};
+declare class Throwable extends Error implements ThrowableType {
+  readonly _tag: typeof NAME;
+  readonly data?: unknown;
+  readonly cause?: Error;
+  readonly taskInfo?: {
+    name: string;
+    description: string;
+  };
+  protected constructor(message: string, options?: {
+    data?: unknown | undefined;
+    cause?: Error | undefined;
+    stack?: string | undefined;
+    taskInfo?: {
+      name: string;
+      description: string;
+    } | undefined;
+  });
+  static apply(srcError: unknown, data?: unknown, taskInfo?: {
+    name: string;
+    description: string;
+  }): ThrowableType;
+}
+//#endregion
+//#region src/fpromise/FPromise.d.ts
+/**
+ * Error context information that provides additional metadata about errors.
+ * This context is passed to error mapping functions to provide more information
+ * about the error that occurred.
+ *
+ * @property originalError - The original error that was thrown
+ * @property stack - The stack trace of the error, if available
+ * @property timestamp - The timestamp when the error occurred
+ */
+type ErrorContext = {
+  originalError: unknown;
+  stack?: string;
+  timestamp: number;
+};
+/**
+ * FPromise is a functional wrapper around JavaScript's Promise with enhanced error handling.
+ * It implements the Functor and AsyncFunctor interfaces, providing map and flatMap operations
+ * for functional composition.
+ *
+ * FPromise adds several features not available in standard Promises:
+ * - Generic error typing for better type safety
+ * - Error recovery mechanisms (recover, recoverWith, recoverWithF)
+ * - Error filtering and categorization
+ * - Side effect methods (tap, tapError)
+ * - Error context preservation
+ * - Conversion to/from Either for more functional error handling
+ *
+ * @template T - The type of the value that the FPromise resolves to
+ * @template E - The type of the error that the FPromise may reject with (defaults to unknown)
+ */
+/**
+ * FPromise type that defines the function signature and methods
+ */
+type FPromise<T$1 extends Type, E extends Type = unknown> = PromiseLike<T$1> & {
+  readonly _tag: "FPromise";
+  tap: (f: (value: T$1) => void) => FPromise<T$1, E>;
+  mapError: <E2>(f: (error: E, context: ErrorContext) => E2) => FPromise<T$1, E2>;
+  tapError: (f: (error: E) => void) => FPromise<T$1, E>;
+  recover: (fallback: T$1) => FPromise<T$1, never>;
+  recoverWith: (f: (error: E) => T$1) => FPromise<T$1, never>;
+  recoverWithF: <E2>(f: (error: E) => FPromise<T$1, E2>) => FPromise<T$1, E2>;
+  filterError: <E2 extends E>(predicate: (error: E) => boolean, handler: (error: E) => FPromise<T$1, E2>) => FPromise<T$1, E>;
+  logError: (logger: (error: E, context: ErrorContext) => void) => FPromise<T$1, E>;
+  toPromise: () => Promise<T$1>;
+  toEither: () => Promise<Either<E, T$1>>;
+  fold: <R$1 extends Type>(onError: (error: E) => R$1, onSuccess: (value: T$1) => R$1) => FPromise<R$1, never>;
+  map: <U extends Type>(f: (value: T$1) => U) => FPromise<U, E>;
+  flatMap: <U extends Type>(f: (value: T$1) => FPromise<U, E> | PromiseLike<U>) => FPromise<U, E>;
+  flatMapAsync: <U extends Type>(f: (value: T$1) => PromiseLike<U>) => Promise<U>;
+};
+/**
+ * Static utility methods for FPromise using the Companion pattern.
+ * These methods provide factory functions and utilities for working with FPromises.
+ */
+declare const FPromiseCompanion: {
+  /**
+   * Creates an FPromise that resolves to the provided value.
+   *
+   * @template T - The type of the value
+   * @template E - The type of the error (defaults to never since this FPromise won't reject)
+   * @param value - The value to resolve with
+   * @returns An FPromise that resolves to the value
+   *
+   * @example
+   * const promise = FPromise.resolve(42)
+   * // promise resolves to 42
+   */
+  resolve: <T$1, E = never>(value: T$1 | PromiseLike<T$1>) => FPromise<T$1, E>;
+  /**
+   * Creates an FPromise that rejects with the provided reason.
+   *
+   * @template T - The type of the value (which will never be produced)
+   * @template E - The type of the error
+   * @param reason - The reason for rejection
+   * @returns An FPromise that rejects with the reason
+   *
+   * @example
+   * const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
+   * // promise rejects with Error("Something went wrong")
+   */
+  reject: <T$1, E = unknown>(reason: E) => FPromise<T$1, E>;
+  /**
+   * Creates an FPromise from a regular Promise.
+   *
+   * @template T - The type of the value
+   * @template E - The type of the error
+   * @param promise - The Promise to convert
+   * @returns An FPromise that resolves or rejects with the same value or error
+   *
+   * @example
+   * const promise = FPromise.from(fetch("https://api.example.com/data"))
+   * // promise is an FPromise that resolves or rejects based on the fetch result
+   */
+  from: <T$1, E = unknown>(promise: Promise<T$1>) => FPromise<T$1, E>;
+  /**
+   * Creates an FPromise from an Either.
+   * If the Either is a Right, the FPromise resolves with the Right value.
+   * If the Either is a Left, the FPromise rejects with the Left value.
+   *
+   * @template L - The type of the Left value (error)
+   * @template R - The type of the Right value (success)
+   * @param either - The Either to convert
+   * @returns An FPromise that resolves or rejects based on the Either
+   *
+   * @example
+   * const either = Right<Error, number>(42)
+   * const promise = FPromise.fromEither(either)
+   * // promise resolves to 42
+   */
+  fromEither: <L, R$1>(either: Either<L, R$1>) => FPromise<R$1, L>;
+  /**
+   * Runs multiple FPromises in parallel and returns an array of results.
+   * Similar to Promise.all, this will reject if any of the promises reject.
+   *
+   * @template T - The type of the values
+   * @template E - The type of the error
+   * @param promises - An array of FPromises, Promises, or values
+   * @returns An FPromise that resolves to an array of results
+   *
+   * @example
+   * const promises = [FPromise.resolve(1), FPromise.resolve(2), 3]
+   * const result = await FPromise.all(promises).toPromise()
+   * // result is [1, 2, 3]
+   */
+  all: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1> | T$1>) => FPromise<T$1[], E>;
+  /**
+   * Like Promise.allSettled, returns results of all promises whether they succeed or fail.
+   * This will always resolve, never reject.
+   *
+   * @template T - The type of the values
+   * @template E - The type of the errors
+   * @param promises - An array of FPromises or Promises
+   * @returns An FPromise that resolves to an array of Either results
+   *
+   * @example
+   * const promises = [FPromise.resolve(1), FPromise.reject<number, Error>(new Error("Failed"))]
+   * const result = await FPromise.allSettled(promises).toPromise()
+   * // result is [Right(1), Left(Error("Failed"))]
+   */
+  allSettled: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<Array<Either<E, T$1>>, never>;
+  /**
+   * Like Promise.race, returns the first promise to settle (either resolve or reject).
+   *
+   * @template T - The type of the values
+   * @template E - The type of the errors
+   * @param promises - An array of FPromises or Promises
+   * @returns An FPromise that resolves or rejects with the result of the first promise to settle
+   *
+   * @example
+   * const slow = FPromise.resolve(1).tap(() => new Promise(r => setTimeout(r, 100)))
+   * const fast = FPromise.resolve(2).tap(() => new Promise(r => setTimeout(r, 50)))
+   * const result = await FPromise.race([slow, fast]).toPromise()
+   * // result is 2
+   */
+  race: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<T$1, E>;
+  /**
+   * Like Promise.any, returns the first promise to fulfill.
+   * This will only reject if all promises reject.
+   *
+   * @template T - The type of the values
+   * @template E - The type of the errors
+   * @param promises - An array of FPromises or Promises
+   * @returns An FPromise that resolves with the first promise to fulfill or rejects if all promises reject
+   *
+   * @example
+   * const promises = [
+   *   FPromise.reject<number, Error>(new Error("First failed")),
+   *   FPromise.resolve(2),
+   *   FPromise.reject<number, Error>(new Error("Third failed"))
+   * ]
+   * const result = await FPromise.any(promises).toPromise()
+   * // result is 2
+   */
+  any: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<T$1, E>;
+  /**
+   * Retries an operation with exponential backoff.
+   * This is useful for operations that may fail temporarily, such as network requests.
+   *
+   * @template T - The type of the value
+   * @template E - The type of the error
+   * @param operation - A function that returns an FPromise
+   * @param options - Configuration options for the retry
+   * @param options.maxRetries - Maximum number of retry attempts
+   * @param options.baseDelay - Base delay in milliseconds (default: 100)
+   * @param options.shouldRetry - Function that determines whether to retry based on the error (default: always retry)
+   * @returns An FPromise that resolves when the operation succeeds or rejects after all retries fail
+   *
+   * @example
+   * const operation = () => {
+   *   if (Math.random() > 0.8) {
+   *     return FPromise.resolve("Success!")
+   *   }
+   *   return FPromise.reject<string, Error>(new Error("Temporary failure"))
+   * }
+   *
+   * const result = await FPromise.retryWithBackoff(operation, {
+   *   maxRetries: 3,
+   *   baseDelay: 100,
+   *   shouldRetry: (error) => error.message === "Temporary failure"
+   * }).toPromise()
+   */
+  retryWithBackoff: <T$1, E = unknown>(operation: () => FPromise<T$1, E>, options: {
+    maxRetries: number;
+    baseDelay?: number;
+    shouldRetry?: (error: E, attempt: number) => boolean;
+  }) => FPromise<T$1, E>;
+};
+/**
+ * Creates an FPromise from an executor function.
+ *
+ * @template T - The type of the value that the FPromise resolves to
+ * @template E - The type of the error that the FPromise may reject with
+ * @param executor - A function that receives resolve and reject functions
+ * @returns An FPromise instance
+ */
+declare const FPromise: (<T$1 extends Type, E = unknown>(executor: (resolve: (value: T$1 | PromiseLike<T$1>) => void, reject: (reason?: E) => void) => void) => FPromise<T$1, E>) & {
+  /**
+   * Creates an FPromise that resolves to the provided value.
+   *
+   * @template T - The type of the value
+   * @template E - The type of the error (defaults to never since this FPromise won't reject)
+   * @param value - The value to resolve with
+   * @returns An FPromise that resolves to the value
+   *
+   * @example
+   * const promise = FPromise.resolve(42)
+   * // promise resolves to 42
+   */
+  resolve: <T$1, E = never>(value: T$1 | PromiseLike<T$1>) => FPromise<T$1, E>;
+  /**
+   * Creates an FPromise that rejects with the provided reason.
+   *
+   * @template T - The type of the value (which will never be produced)
+   * @template E - The type of the error
+   * @param reason - The reason for rejection
+   * @returns An FPromise that rejects with the reason
+   *
+   * @example
+   * const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
+   * // promise rejects with Error("Something went wrong")
+   */
+  reject: <T$1, E = unknown>(reason: E) => FPromise<T$1, E>;
+  /**
+   * Creates an FPromise from a regular Promise.
+   *
+   * @template T - The type of the value
+   * @template E - The type of the error
+   * @param promise - The Promise to convert
+   * @returns An FPromise that resolves or rejects with the same value or error
+   *
+   * @example
+   * const promise = FPromise.from(fetch("https://api.example.com/data"))
+   * // promise is an FPromise that resolves or rejects based on the fetch result
+   */
+  from: <T$1, E = unknown>(promise: Promise<T$1>) => FPromise<T$1, E>;
+  /**
+   * Creates an FPromise from an Either.
+   * If the Either is a Right, the FPromise resolves with the Right value.
+   * If the Either is a Left, the FPromise rejects with the Left value.
+   *
+   * @template L - The type of the Left value (error)
+   * @template R - The type of the Right value (success)
+   * @param either - The Either to convert
+   * @returns An FPromise that resolves or rejects based on the Either
+   *
+   * @example
+   * const either = Right<Error, number>(42)
+   * const promise = FPromise.fromEither(either)
+   * // promise resolves to 42
+   */
+  fromEither: <L, R$1>(either: Either<L, R$1>) => FPromise<R$1, L>;
+  /**
+   * Runs multiple FPromises in parallel and returns an array of results.
+   * Similar to Promise.all, this will reject if any of the promises reject.
+   *
+   * @template T - The type of the values
+   * @template E - The type of the error
+   * @param promises - An array of FPromises, Promises, or values
+   * @returns An FPromise that resolves to an array of results
+   *
+   * @example
+   * const promises = [FPromise.resolve(1), FPromise.resolve(2), 3]
+   * const result = await FPromise.all(promises).toPromise()
+   * // result is [1, 2, 3]
+   */
+  all: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1> | T$1>) => FPromise<T$1[], E>;
+  /**
+   * Like Promise.allSettled, returns results of all promises whether they succeed or fail.
+   * This will always resolve, never reject.
+   *
+   * @template T - The type of the values
+   * @template E - The type of the errors
+   * @param promises - An array of FPromises or Promises
+   * @returns An FPromise that resolves to an array of Either results
+   *
+   * @example
+   * const promises = [FPromise.resolve(1), FPromise.reject<number, Error>(new Error("Failed"))]
+   * const result = await FPromise.allSettled(promises).toPromise()
+   * // result is [Right(1), Left(Error("Failed"))]
+   */
+  allSettled: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<Array<Either<E, T$1>>, never>;
+  /**
+   * Like Promise.race, returns the first promise to settle (either resolve or reject).
+   *
+   * @template T - The type of the values
+   * @template E - The type of the errors
+   * @param promises - An array of FPromises or Promises
+   * @returns An FPromise that resolves or rejects with the result of the first promise to settle
+   *
+   * @example
+   * const slow = FPromise.resolve(1).tap(() => new Promise(r => setTimeout(r, 100)))
+   * const fast = FPromise.resolve(2).tap(() => new Promise(r => setTimeout(r, 50)))
+   * const result = await FPromise.race([slow, fast]).toPromise()
+   * // result is 2
+   */
+  race: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<T$1, E>;
+  /**
+   * Like Promise.any, returns the first promise to fulfill.
+   * This will only reject if all promises reject.
+   *
+   * @template T - The type of the values
+   * @template E - The type of the errors
+   * @param promises - An array of FPromises or Promises
+   * @returns An FPromise that resolves with the first promise to fulfill or rejects if all promises reject
+   *
+   * @example
+   * const promises = [
+   *   FPromise.reject<number, Error>(new Error("First failed")),
+   *   FPromise.resolve(2),
+   *   FPromise.reject<number, Error>(new Error("Third failed"))
+   * ]
+   * const result = await FPromise.any(promises).toPromise()
+   * // result is 2
+   */
+  any: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<T$1, E>;
+  /**
+   * Retries an operation with exponential backoff.
+   * This is useful for operations that may fail temporarily, such as network requests.
+   *
+   * @template T - The type of the value
+   * @template E - The type of the error
+   * @param operation - A function that returns an FPromise
+   * @param options - Configuration options for the retry
+   * @param options.maxRetries - Maximum number of retry attempts
+   * @param options.baseDelay - Base delay in milliseconds (default: 100)
+   * @param options.shouldRetry - Function that determines whether to retry based on the error (default: always retry)
+   * @returns An FPromise that resolves when the operation succeeds or rejects after all retries fail
+   *
+   * @example
+   * const operation = () => {
+   *   if (Math.random() > 0.8) {
+   *     return FPromise.resolve("Success!")
+   *   }
+   *   return FPromise.reject<string, Error>(new Error("Temporary failure"))
+   * }
+   *
+   * const result = await FPromise.retryWithBackoff(operation, {
+   *   maxRetries: 3,
+   *   baseDelay: 100,
+   *   shouldRetry: (error) => error.message === "Temporary failure"
+   * }).toPromise()
+   */
+  retryWithBackoff: <T$1, E = unknown>(operation: () => FPromise<T$1, E>, options: {
+    maxRetries: number;
+    baseDelay?: number;
+    shouldRetry?: (error: E, attempt: number) => boolean;
+  }) => FPromise<T$1, E>;
+};
+//#endregion
+//#region src/core/task/Task.d.ts
+/**
+ * Type definition for errors with a _tag property that identifies them as Throwables
+ */
+type TaggedThrowable = Error & {
+  _tag: "Throwable";
+  cause?: Error;
+  taskInfo?: {
+    name: string;
+    description: string;
+  };
+};
+/**
+ * Type guard to check if an error is a TaggedThrowable
+ */
+declare function isTaggedThrowable(error: unknown): error is TaggedThrowable;
+interface TaskParams {
+  readonly name?: string;
+  readonly description?: string;
+}
+interface TaskMetadata {
+  readonly name: string;
+  readonly description: string;
+}
+interface TaskOutcome<T$1> extends FunctypeBase<T$1, "Ok" | "Err">, Extractable<T$1>, AsyncMonad<T$1>, Promisable<T$1>, Doable<T$1> {
+  readonly _tag: "Ok" | "Err";
+  readonly _meta: TaskMetadata;
+  readonly value?: T$1;
+  readonly error?: Throwable;
+  readonly map: <U>(f: (value: T$1) => U) => TaskOutcome<U>;
+  readonly flatMap: <U>(f: (value: T$1) => TaskOutcome<U> | Either<Throwable, U>) => TaskOutcome<U>;
+  readonly ap: <U>(ff: TaskOutcome<(value: T$1) => U>) => TaskOutcome<U>;
+  readonly mapAsync: <U>(f: (value: T$1) => Promise<U>) => Promise<TaskOutcome<U>>;
+  readonly flatMapAsync: <U>(f: (value: T$1) => Promise<TaskOutcome<U>>) => Promise<TaskOutcome<U>>;
+  readonly mapError: (f: (error: Throwable) => Throwable) => TaskOutcome<T$1>;
+  readonly recover: (value: T$1) => Ok<T$1>;
+  readonly recoverWith: (f: (error: Throwable) => T$1) => Ok<T$1>;
+  readonly isSuccess: () => this is Ok<T$1>;
+  readonly isFailure: () => this is Err<T$1>;
+  readonly isOk: () => this is Ok<T$1>;
+  readonly isErr: () => this is Err<T$1>;
+  readonly toEither: () => Either<Throwable, T$1>;
+  readonly toTry: () => Try<T$1>;
+  readonly toOption: () => Option<T$1>;
+  readonly toList: () => List<T$1>;
+  readonly fold: <U>(onErr: (error: Throwable) => U, onOk: (value: T$1) => U) => U;
+  readonly match: <U>(patterns: {
+    Ok: (value: T$1) => U;
+    Err: (error: Throwable) => U;
+  }) => U;
+}
+interface Ok<T$1> extends TaskOutcome<T$1> {
+  readonly _tag: "Ok";
+  readonly value: T$1;
+  readonly error: undefined;
+}
+interface Err<T$1> extends TaskOutcome<T$1> {
+  readonly _tag: "Err";
+  readonly value: undefined;
+  readonly error: Throwable;
+}
+type TaskSuccess<T$1> = Ok<T$1>;
+type TaskFailure<T$1> = Err<T$1>;
+/**
+ * Err constructor - Creates a failed TaskOutcome
+ * @param error - The error object
+ * @param data - Additional data related to the error
+ * @param params - Task parameters
+ */
+declare const Err: <T$1>(error: unknown, data?: unknown, params?: TaskParams) => Err<T$1>;
+/**
+ * Ok constructor - Creates a successful TaskOutcome
+ * @param data - The successful value
+ * @param params - Task parameters
+ */
+declare const Ok: <T$1>(data: T$1, params?: TaskParams) => Ok<T$1>;
+type TaskResult<T$1> = Promise<TaskOutcome<T$1>>;
+/**
+ * The CancellationToken is a control structure that allows long-running tasks to be cancelled
+ * Cancellation is cooperative, meaning the task must check the token and respond to cancellation requests
+ */
+type CancellationToken = {
+  /** Whether the token has been cancelled */
+  readonly isCancelled: boolean;
+  /** Signal that can be used with fetch and other abortable APIs */
+  readonly signal: AbortSignal;
+  /** Register a callback to be called when cancellation occurs */
+  onCancel(callback: () => void): void;
+};
+/**
+ * Create a cancellation token and controller
+ * The controller can be used to cancel operations that use the token
+ */
+type CancellationTokenSource = {
+  /** The token to be passed to cancellable operations */
+  readonly token: CancellationToken;
+  /** Cancel all operations using this token */
+  cancel(): void;
+};
+/**
+ * Create a cancellation token source
+ * @returns A CancellationTokenSource that can be used to create and control cancellation tokens
+ */
+declare const createCancellationTokenSource: () => CancellationTokenSource;
+type Sync<T$1> = TaskOutcome<T$1>;
+type Async<T$1> = TaskResult<T$1>;
+declare const Task: (<T$1 = unknown>(params?: TaskParams) => {
+  _type: string;
+  /**
+   * Run an async operation with explicit try/catch/finally semantics
+   * Returns a raw Promise that can interact with traditional Promise-based code
+   *
+   * @param t - The main operation function that returns a value or Promise
+   * @param e - Optional error handler function
+   * @param f - Optional finally handler function
+   * @param cancellationToken - Optional token for cancellation support
+   */
+  Async: <U = T$1>(t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<TaskOutcome<U>>;
+  /**
+   * Run a synchronous operation with explicit try/catch/finally semantics
+   * Returns a TaskOutcome for functional error handling
+   *
+   * @param t - The main operation function that returns a value
+   * @param e - Optional error handler function
+   * @param f - Optional finally handler function
+   */
+  Sync: <U = T$1>(t: () => U, e?: (error: unknown) => unknown, f?: () => void) => TaskOutcome<U>;
+  /**
+   * Run an async operation with progress tracking capabilities
+   * Returns a Promise and provides progress updates via callback
+   *
+   * @param t - The main operation that receives a progress updater function
+   * @param onProgress - Callback that receives progress updates (0-100)
+   * @param e - Optional error handler function
+   * @param f - Optional finally handler function
+   * @param cancellationToken - Optional token for cancellation support
+   */
+  AsyncWithProgress: <U = T$1>(t: (updateProgress: (percent: number) => void) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, onProgress: (percent: number) => void, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<TaskOutcome<U>>;
+  toString(): string;
+  doUnwrap(): DoResult<unknown>;
+  _tag: string;
+}) & {
+  /**
+   * Create a successful Task result
+   */
+  success: <T$1>(data: T$1, params?: TaskParams) => Ok<T$1>;
+  /**
+   * Create a failed Task result
+   */
+  fail: <T$1>(error: unknown, data?: unknown, params?: TaskParams) => Err<T$1>;
+  /**
+   * Create a successful Task result (alias for success)
+   * Preferred for new code
+   */
+  ok: <T$1>(data: T$1, params?: TaskParams) => Ok<T$1>;
+  /**
+   * Create a failed Task result (alias for fail)
+   * Preferred for new code
+   */
+  err: <T$1>(error: unknown, data?: unknown, params?: TaskParams) => Err<T$1>;
+  /**
+   * Create TaskOutcome from Either
+   * @param either - Either to convert
+   * @param params - Task parameters
+   */
+  fromEither: <T$1>(either: Either<Throwable, T$1>, params?: TaskParams) => TaskOutcome<T$1>;
+  /**
+   * Create TaskOutcome from Try
+   * @param tryValue - Try to convert
+   * @param params - Task parameters
+   */
+  fromTry: <T$1>(tryValue: Try<T$1>, params?: TaskParams) => TaskOutcome<T$1>;
+  /**
+   * Extract the error chain from a Throwable error
+   * Returns an array of errors from outermost to innermost
+   *
+   * @param error - The error to extract the chain from
+   * @returns An array of errors in the chain, from outermost to innermost
+   */
+  getErrorChain: (error: Error | undefined) => Error[];
+  /**
+   * Format the error chain as a string with the option to include task details
+   *
+   * @param error - The error to format
+   * @param options - Formatting options
+   * @returns A formatted string representation of the error chain
+   */
+  formatErrorChain: (error: Error | undefined, options?: {
+    includeTasks?: boolean;
+    separator?: string;
+    includeStackTrace?: boolean;
+  }) => string;
+  /**
+   * Convert a Promise-returning function to a Task-compatible function
+   */
+  fromPromise: <U, Args extends unknown[]>(promiseFn: (...args: Args) => Promise<U>, params?: TaskParams) => ((...args: Args) => FPromise<TaskOutcome<U>>);
+  /**
+   * Convert a Task result to a Promise
+   */
+  toPromise: <U>(taskOutcome: TaskOutcome<U>) => Promise<U>;
+  /**
+   * Race multiple tasks and return the result of the first one to complete
+   * Optionally specify a timeout after which the race will fail
+   *
+   * @param tasks - Array of tasks to race (as FPromises)
+   * @param timeoutMs - Optional timeout in milliseconds
+   * @param params - Task parameters for the race operation
+   * @returns A promise that resolves with the first task to complete or rejects if all tasks fail
+   */
+  race: <T$1>(tasks: Array<FPromise<T$1> | FPromise<TaskOutcome<T$1>>>, timeoutMs?: number, params?: TaskParams) => FPromise<TaskOutcome<T$1>>;
+  /**
+   * Convert a Node.js style callback function to a Task-compatible function
+   * Node.js callbacks typically have the signature (error, result) => void
+   *
+   * @param nodeFn - Function that accepts a Node.js style callback
+   * @param params - Task parameters
+   * @returns A function that returns an FPromise
+   */
+  fromNodeCallback: <T$1, Args extends unknown[]>(nodeFn: (...args: [...Args, (error: unknown, result: T$1) => void]) => void, params?: TaskParams) => ((...args: Args) => FPromise<TaskOutcome<T$1>>);
+  /**
+   * Create a cancellation token source
+   * @returns A cancellation token source that can be used to control task cancellation
+   */
+  createCancellationTokenSource: () => CancellationTokenSource;
+  /**
+   * Create a task that can be cancelled
+   *
+   * @param task - The task function to make cancellable
+   * @param params - Task parameters
+   * @returns An object with the task and a function to cancel it
+   */
+  cancellable: <T$1>(task: (token: CancellationToken) => Promise<T$1> | Promise<TaskOutcome<T$1>>, params?: TaskParams) => {
+    task: FPromise<TaskOutcome<T$1>>;
+    cancel: () => void;
+  };
+  /**
+   * Creates a task with progress tracking
+   *
+   * @param task - The task function that accepts a progress updater
+   * @param onProgress - Callback function that receives progress updates
+   * @param params - Task parameters
+   * @returns An object with the task, cancel function, and current progress
+   */
+  withProgress: <T$1>(task: (updateProgress: (percent: number) => void, token: CancellationToken) => Promise<T$1> | Promise<TaskOutcome<T$1>>, onProgress?: (percent: number) => void, params?: TaskParams) => {
+    task: FPromise<TaskOutcome<T$1>>;
+    cancel: () => void;
+    currentProgress: () => number;
+  };
+};
+type Task = ReturnType<typeof Task>;
+//#endregion
+//#region src/error/ErrorFormatter.d.ts
+/**
+ * Type definition for task information that may be attached to errors
+ */
+type TaskErrorInfo = {
+  name?: string;
+  description?: string;
+  [key: string]: unknown;
+};
+/**
+ * Type definition for an error with potential task information
+ */
+type ErrorWithTaskInfo = Error & {
+  taskInfo?: TaskErrorInfo;
+  data?: unknown;
+};
+/**
+ * Type definition for a structured error chain element
+ */
+type ErrorChainElement = {
+  message?: string;
+  name?: string;
+  taskInfo?: TaskErrorInfo;
+  stack?: string;
+  [key: string]: unknown;
+};
+/**
+ * Options for formatting error chains
+ */
+type ErrorFormatterOptions = {
+  /** Include task names in the formatted output */
+  includeTasks?: boolean;
+  /** Include stack traces in the formatted output */
+  includeStackTrace?: boolean;
+  /** Separator between error lines (default: newline) */
+  separator?: string;
+  /** Include detailed error data in the output */
+  includeData?: boolean;
+  /** Maximum number of stack frames to include if stack trace is enabled */
+  maxStackFrames?: number;
+  /** Title to display at the start of the formatted error */
+  title?: string;
+  /** Format the output with colors for console display */
+  colors?: boolean;
+};
+/**
+ * Safely stringify data including BigInt values and circular references
+ */
+declare function safeStringify(obj: unknown): string;
+/**
+ * Format a stack trace string for better readability
+ */
+declare function formatStackTrace(stack: string | undefined): string;
+/**
+ * Create a formatted string representation of an error for better logging and display
+ *
+ * @example
+ * ```typescript
+ * const error = new Error("Something went wrong");
+ * console.error(formatError(error, { colors: true, includeData: true }));
+ * ```
+ */
+declare function formatError(error: unknown, options?: ErrorFormatterOptions): string;
+/**
+ * Create a serializer function for Pino or other JSON loggers
+ * to better represent errors with their full context
+ */
+declare function createErrorSerializer(): (err: unknown) => unknown;
+//#endregion
+//#region src/error/ParseError.d.ts
+declare const ParseError: (message?: string) => Error & {
+  name: "ParseError";
+};
+type ParseError = Error & {
+  name: "ParseError";
+};
+//#endregion
+//#region src/error/typed/TypedError.d.ts
+/**
+ * Type-safe error codes using template literal types
+ */
+type ErrorCode = "VALIDATION_FAILED" | "NETWORK_ERROR" | "AUTH_REQUIRED" | "NOT_FOUND" | "PERMISSION_DENIED" | "RATE_LIMITED" | "INTERNAL_ERROR" | "BAD_REQUEST" | "CONFLICT" | "TIMEOUT";
+/**
+ * Template literal type for error messages based on error code
+ */
+type ErrorMessage<T$1 extends ErrorCode> = T$1 extends "VALIDATION_FAILED" ? `Validation failed: ${string}` : T$1 extends "NETWORK_ERROR" ? `Network error: ${string}` : T$1 extends "AUTH_REQUIRED" ? `Authentication required: ${string}` : T$1 extends "NOT_FOUND" ? `Not found: ${string}` : T$1 extends "PERMISSION_DENIED" ? `Permission denied: ${string}` : T$1 extends "RATE_LIMITED" ? `Rate limit exceeded: ${string}` : T$1 extends "INTERNAL_ERROR" ? `Internal server error: ${string}` : T$1 extends "BAD_REQUEST" ? `Bad request: ${string}` : T$1 extends "CONFLICT" ? `Conflict: ${string}` : T$1 extends "TIMEOUT" ? `Request timeout: ${string}` : never;
+/**
+ * HTTP status codes mapped to error codes
+ */
+type ErrorStatus<T$1 extends ErrorCode> = T$1 extends "VALIDATION_FAILED" | "BAD_REQUEST" ? 400 : T$1 extends "AUTH_REQUIRED" ? 401 : T$1 extends "PERMISSION_DENIED" ? 403 : T$1 extends "NOT_FOUND" ? 404 : T$1 extends "CONFLICT" ? 409 : T$1 extends "RATE_LIMITED" ? 429 : T$1 extends "TIMEOUT" ? 408 : T$1 extends "INTERNAL_ERROR" ? 500 : T$1 extends "NETWORK_ERROR" ? 503 : 500;
+/**
+ * Context type for each error code
+ */
+type TypedErrorContext<T$1 extends ErrorCode> = T$1 extends "VALIDATION_FAILED" ? {
+  field: string;
+  value: unknown;
+  rule: string;
+} : T$1 extends "NETWORK_ERROR" ? {
+  url: string;
+  method: string;
+  statusCode?: number;
+} : T$1 extends "AUTH_REQUIRED" ? {
+  resource: string;
+  requiredRole?: string;
+} : T$1 extends "NOT_FOUND" ? {
+  resource: string;
+  id: string | number;
+} : T$1 extends "PERMISSION_DENIED" ? {
+  action: string;
+  resource: string;
+  userId?: string;
+} : T$1 extends "RATE_LIMITED" ? {
+  limit: number;
+  window: string;
+  retryAfter?: number;
+} : T$1 extends "INTERNAL_ERROR" ? {
+  errorId: string;
+  timestamp: string;
+} : T$1 extends "BAD_REQUEST" ? {
+  reason: string;
+  expected?: string;
+} : T$1 extends "CONFLICT" ? {
+  resource: string;
+  conflictingValue: string;
+} : T$1 extends "TIMEOUT" ? {
+  duration: number;
+  operation: string;
+} : Record<string, unknown>;
+/**
+ * Type-safe error class with template literal types
+ */
+interface TypedError<T$1 extends ErrorCode> extends Throwable {
+  readonly code: T$1;
+  readonly message: ErrorMessage<T$1>;
+  readonly status: ErrorStatus<T$1>;
+  readonly context: TypedErrorContext<T$1>;
+  readonly timestamp: string;
+  readonly traceId?: string;
+}
+declare const TypedError: (<T$1 extends ErrorCode>(code: T$1, message: ErrorMessage<T$1>, context: TypedErrorContext<T$1>, options?: {
+  cause?: unknown;
+  traceId?: string;
+}) => TypedError<T$1>) & {
+  /**
+   * Create a validation error
+   * @example
+   * const error = TypedError.validation("email", "test@", "must be valid email")
+   * // Type: TypedError<"VALIDATION_FAILED">
+   * // Message must match: "Validation failed: ..."
+   */
+  validation: (field: string, value: unknown, rule: string) => TypedError<"VALIDATION_FAILED">;
+  /**
+   * Create a network error
+   * @example
+   * const error = TypedError.network("https://api.example.com", "POST", 500)
+   * // Type: TypedError<"NETWORK_ERROR">
+   */
+  network: (url: string, method: string, statusCode?: number) => TypedError<"NETWORK_ERROR">;
+  /**
+   * Create an authentication error
+   * @example
+   * const error = TypedError.auth("/api/admin", "admin")
+   * // Type: TypedError<"AUTH_REQUIRED">
+   */
+  auth: (resource: string, requiredRole?: string) => TypedError<"AUTH_REQUIRED">;
+  /**
+   * Create a not found error
+   * @example
+   * const error = TypedError.notFound("user", "123")
+   * // Type: TypedError<"NOT_FOUND">
+   */
+  notFound: (resource: string, id: string | number) => TypedError<"NOT_FOUND">;
+  /**
+   * Create a permission denied error
+   * @example
+   * const error = TypedError.permission("delete", "post", "user123")
+   * // Type: TypedError<"PERMISSION_DENIED">
+   */
+  permission: (action: string, resource: string, userId?: string) => TypedError<"PERMISSION_DENIED">;
+  /**
+   * Create a rate limit error
+   * @example
+   * const error = TypedError.rateLimit(100, "1h", 3600)
+   * // Type: TypedError<"RATE_LIMITED">
+   */
+  rateLimit: (limit: number, window: string, retryAfter?: number) => TypedError<"RATE_LIMITED">;
+  /**
+   * Create an internal error
+   * @example
+   * const error = TypedError.internal("ERR-500-ABC123")
+   * // Type: TypedError<"INTERNAL_ERROR">
+   */
+  internal: (errorId: string) => TypedError<"INTERNAL_ERROR">;
+  /**
+   * Create a bad request error
+   * @example
+   * const error = TypedError.badRequest("Invalid JSON", "valid JSON object")
+   * // Type: TypedError<"BAD_REQUEST">
+   */
+  badRequest: (reason: string, expected?: string) => TypedError<"BAD_REQUEST">;
+  /**
+   * Create a conflict error
+   * @example
+   * const error = TypedError.conflict("email", "user@example.com")
+   * // Type: TypedError<"CONFLICT">
+   */
+  conflict: (resource: string, conflictingValue: string) => TypedError<"CONFLICT">;
+  /**
+   * Create a timeout error
+   * @example
+   * const error = TypedError.timeout(30000, "database query")
+   * // Type: TypedError<"TIMEOUT">
+   */
+  timeout: (duration: number, operation: string) => TypedError<"TIMEOUT">;
+  /**
+   * Check if a value is a TypedError
+   */
+  isTypedError: (value: unknown) => value is TypedError<ErrorCode>;
+  /**
+   * Check if a TypedError has a specific code
+   */
+  hasCode: <T$1 extends ErrorCode>(error: TypedError<ErrorCode>, code: T$1) => error is TypedError<T$1>;
+};
+//#endregion
+//#region src/error/typed/Validation.d.ts
+/**
+ * Validation rule types using template literal types
+ */
+type ValidationRule = `min:${number}` | `max:${number}` | `minLength:${number}` | `maxLength:${number}` | `pattern:${string}` | `email` | `url` | `uuid` | `required` | `numeric` | `alpha` | `alphanumeric` | `date` | `future` | `past` | `in:${string}` | `notIn:${string}`;
+/**
+ * Validator function type
+ */
+type Validator<T$1> = (value: unknown) => Either<TypedError<"VALIDATION_FAILED">, T$1>;
+/**
+ * Field validation result
+ */
+type FieldValidation<T$1> = {
+  field: string;
+  value: unknown;
+  result: Either<TypedError<"VALIDATION_FAILED">, T$1>;
+};
+/**
+ * Form validation result
+ */
+type FormValidation<T$1 extends Record<string, Type>> = Either<List<TypedError<"VALIDATION_FAILED">>, T$1>;
+declare const Validation: (<T$1 extends Type>(rule: ValidationRule) => Validator<T$1>) & {
+  /**
+   * Common pre-built validators
+   */
+  validators: {
+    email: Validator<string>;
+    url: Validator<string>;
+    uuid: Validator<string>;
+    required: Validator<string>;
+    numeric: Validator<number>;
+    positiveNumber: Validator<number>;
+    nonEmptyString: Validator<string>;
+  };
+  /**
+   * Create a validator from a rule string
+   * @example
+   * const validator = Validation.rule<number>("min:18")
+   * const result = validator(25) // Right(25)
+   * const error = validator(15) // Left(TypedError)
+   */
+  rule: <T$1 extends Type>(rule: ValidationRule) => Validator<T$1>;
+  /**
+   * Combine multiple validators
+   * @example
+   * const validator = Validation.combine(
+   *   Validation.rule<string>("required"),
+   *   Validation.rule<string>("email"),
+   *   Validation.rule<string>("maxLength:100")
+   * )
+   */
+  combine: <T$1 extends Type>(...validators: Validator<T$1>[]) => Validator<T$1>;
+  /**
+   * Create a custom validator
+   * @example
+   * const isEven = Validation.custom<number>(
+   *   (value) => typeof value === "number" && value % 2 === 0,
+   *   "must be an even number"
+   * )
+   */
+  custom: <T$1 extends Type>(predicate: (value: unknown) => boolean, errorMessage: string) => Validator<T$1>;
+  /**
+   * Validate a form with multiple fields
+   * @example
+   * const schema = {
+   *   name: Validation.rule<string>("required"),
+   *   email: Validation.rule<string>("email"),
+   *   age: Validation.rule<number>("min:18")
+   * }
+   * const result = Validation.form(schema, { name: "John", email: "john@example.com", age: 25 })
+   */
+  form: <T$1 extends Record<string, Type>>(schema: { [K in keyof T$1]: Validator<T$1[K]> }, data: Record<string, unknown>) => FormValidation<T$1>;
+};
+//#endregion
+//#region src/foldable/index.d.ts
+/**
+ * Utility functions for working with Foldable data structures
+ */
+declare const FoldableUtils: {
+  /**
+   * Converts a Foldable to an Option
+   *
+   * @param foldable - The foldable structure to convert
+   * @returns An Option containing the value, or None if empty
+   */
+  toOption: <A extends Type>(foldable: Foldable<A>) => Option<A>;
+  /**
+   * Converts a Foldable to a List
+   *
+   * @param foldable - The foldable structure to convert
+   * @returns A List containing the value(s), or empty List if empty
+   */
+  toList: <A extends Type>(foldable: Foldable<A>) => List<A>;
+  /**
+   * Converts a Foldable to an Either
+   *
+   * @param foldable - The foldable structure to convert
+   * @param left - The value to use for Left if empty
+   * @returns Either.Right with the value if non-empty, or Either.Left with left if empty
+   */
+  toEither: <A extends Type, E>(foldable: Foldable<A>, left: E) => Either<E, A>;
+  /**
+   * Checks if the Foldable is empty
+   *
+   * @param foldable - The foldable structure to check
+   * @returns true if empty, false otherwise
+   */
+  isEmpty: <A extends Type>(foldable: Foldable<A>) => boolean;
+  /**
+   * Calculates the size of the Foldable
+   *
+   * @param foldable - The foldable structure to measure
+   * @returns The size (number of elements)
+   */
+  size: <A extends Type>(foldable: Foldable<A>) => number;
+};
+//#endregion
+//#region src/hkt/index.d.ts
+/**
+ * Type function for representing higher-kinded types
+ */
+type Kind<F, A> = F extends ((arg: infer T) => infer R) ? R : never;
+/**
+ * Type constructors for common Functype data types
+ */
+type OptionKind = <A>(a: A) => Option<A>;
+type ListKind = <A>(a: A) => List<A>;
+type EitherKind<E> = <A>(a: A) => Either<E, A>;
+type TryKind = <A>(a: A) => Try<A>;
+/**
+ * Generic container types for type-safe operations
+ * @internal
+ */
+type Mappable<T$1> = {
+  map<U>(f: (value: T$1) => U): unknown;
+};
+/**
+ * @internal
+ */
+type Flattenable = {
+  flatten(): unknown;
+};
+/**
+ * @internal
+ */
+type FlatMappable<T$1> = {
+  flatMap<U>(f: (value: T$1) => unknown): unknown;
+};
+/**
+ * Universal type that includes all potential return types from the HKT functions
+ * Used to avoid 'any' usage which the linter prohibits
+ */
+type UniversalContainer = Option<unknown> | List<unknown> | Either<unknown, unknown> | Try<unknown>;
+/**
+ * HKT provides utilities for working with higher-kinded types
+ * This allows writing generic code that works across different
+ * container types like Option, List, Either, etc.
+ */
+declare const HKT: {
+  (): {
+    _tag: string;
+    map: <F, A, B>(fa: unknown, f: (a: A) => B) => unknown;
+    flatten: <F, A>(ffa: unknown) => unknown;
+    flatMap: <F, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
+    ap: <F, A, B>(ff: unknown, fa: unknown) => unknown;
+    sequence: <F, G, A>(fga: unknown) => unknown;
+    traverse: <F, G, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
+    _type: string;
+  };
+  map<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => B): unknown;
+  flatten<F = unknown, A = unknown>(ffa: unknown): unknown;
+  flatMap<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
+  ap<F = unknown, A = unknown, B = unknown>(ff: unknown, fa: unknown): unknown;
+  sequence<F = unknown, G = unknown, A = unknown>(fga: unknown): unknown;
+  traverse<F = unknown, G = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
+  isOption: <T$1 extends Type>(value: unknown) => value is Option<T$1> & Mappable<T$1> & FlatMappable<T$1>;
+  isList: <T$1 extends Type>(value: unknown) => value is List<T$1> & Mappable<T$1> & Flattenable & FlatMappable<T$1>;
+  isEither: <E extends Type, A extends Type>(value: unknown) => value is Either<E, A> & Mappable<A> & FlatMappable<A>;
+  isTry: <T$1 extends Type>(value: unknown) => value is Try<T$1> & Mappable<T$1> & FlatMappable<T$1>;
+};
+//#endregion
+//#region src/identity/Identity.d.ts
+type Identity<T$1> = {
+  id: T$1;
+  isSame?: (other: Identity<T$1>) => boolean;
+};
+declare const Identity: (<T$1>(value: T$1) => Identity<T$1>) & {
+  /**
+   * Creates an Identity. Alias for Identity constructor.
+   * @param value - The value to wrap
+   * @returns Identity instance
+   */
+  of: <T$1>(value: T$1) => Identity<T$1>;
+  /**
+   * Creates an Identity. Same as of.
+   * @param value - The value to wrap
+   * @returns Identity instance
+   */
+  pure: <T$1>(value: T$1) => Identity<T$1>;
+};
+//#endregion
+//#region src/lazy/Lazy.d.ts
+/**
+ * Lazy type module
+ * @module Lazy
+ * @category Core
+ */
+/**
+ * The Lazy type represents a computation that is deferred until needed.
+ * It provides memoization and safe evaluation with integration to Option, Either, and Try.
+ * @typeParam T - The type of the value to be computed
+ */
+interface Lazy<T$1 extends Type> extends FunctypeBase<T$1, "Lazy">, Extractable<T$1>, Pipe<T$1> {
+  /** Tag identifying this as a Lazy type */
+  readonly _tag: "Lazy";
+  /** Whether the computation has been evaluated */
+  readonly isEvaluated: boolean;
+  /**
+   * Returns the computed value or a default value if computation fails
+   * @param defaultValue - The value to return if computation fails
+   * @returns The computed value or defaultValue
+   */
+  orElse(defaultValue: T$1): T$1;
+  /**
+   * Returns the computed value or null if computation fails
+   * @returns The computed value or null
+   */
+  orNull(): T$1 | null;
+  /**
+   * Returns the computed value or throws an error if computation fails
+   * @param error - Optional custom error to throw. If not provided, throws the computation error or a default error
+   * @returns The computed value
+   * @throws The specified error, computation error, or a default error
+   */
+  orThrow(error?: Error): T$1;
+  /**
+   * Returns this Lazy if computation succeeds, otherwise returns the alternative Lazy
+   * @param alternative - The alternative Lazy to use if computation fails
+   * @returns This Lazy or the alternative
+   */
+  or(alternative: Lazy<T$1>): Lazy<T$1>;
+  /**
+   * Maps the value inside the Lazy using the provided function
+   * @param f - The mapping function
+   * @returns A new Lazy containing the mapped value
+   */
+  map<U extends Type>(f: (value: T$1) => U): Lazy<U>;
+  /**
+   * Applies a wrapped function to a wrapped value (Applicative pattern)
+   * @param ff - A Lazy containing a function from T to U
+   * @returns A new Lazy containing the result
+   */
+  ap<U extends Type>(ff: Lazy<(value: T$1) => U>): Lazy<U>;
+  /**
+   * Maps the value inside the Lazy using an async function
+   * @param f - The async mapping function
+   * @returns A Promise of a new Lazy containing the mapped value
+   */
+  mapAsync<U extends Type>(f: (value: T$1) => Promise<U>): Promise<Lazy<U>>;
+  /**
+   * Maps the value using a function that returns a Lazy
+   * @param f - The mapping function returning a Lazy
+   * @returns A new Lazy containing the flattened result
+   */
+  flatMap<U extends Type>(f: (value: T$1) => Lazy<U>): Lazy<U>;
+  /**
+   * Maps the value using an async function that returns a Lazy
+   * @param f - The async mapping function returning a Lazy
+   * @returns A Promise of a new Lazy containing the flattened result
+   */
+  flatMapAsync<U extends Type>(f: (value: T$1) => Promise<Lazy<U>>): Promise<Lazy<U>>;
+  /**
+   * Returns a Lazy that filters the value based on a predicate
+   * @param predicate - The predicate function
+   * @returns A Lazy containing an Option of the value
+   */
+  filter(predicate: (value: T$1) => boolean): Lazy<Option<T$1>>;
+  /**
+   * Recovers from a failed computation by providing an alternative value
+   * @param f - Function that takes the error and returns a recovery value
+   * @returns A new Lazy that will use the recovery function if computation fails
+   */
+  recover(f: (error: unknown) => T$1): Lazy<T$1>;
+  /**
+   * Recovers from a failed computation by providing an alternative Lazy
+   * @param f - Function that takes the error and returns a recovery Lazy
+   * @returns A new Lazy that will use the recovery Lazy if computation fails
+   */
+  recoverWith(f: (error: unknown) => Lazy<T$1>): Lazy<T$1>;
+  /**
+   * Evaluates the computation and returns it as an Option
+   * @returns Some containing the value if successful, None if computation fails
+   */
+  toOption(): Option<T$1>;
+  /**
+   * Evaluates the computation and returns it as an Either
+   * @returns Right containing the value if successful, Left containing the error if computation fails
+   */
+  toEither(): Either<unknown, T$1>;
+  /**
+   * Evaluates the computation and returns it as an Either with a mapped error
+   * @param mapError - Function to map the error
+   * @returns Right containing the value if successful, Left containing the mapped error if computation fails
+   */
+  toEitherWith<E>(mapError: (error: unknown) => E): Either<E, T$1>;
+  /**
+   * Evaluates the computation and returns it as a Try
+   * @returns Try containing the result of the computation
+   */
+  toTry(): Try<T$1>;
+  /**
+   * Applies an effect function to the value if computation succeeds
+   * @param f - The effect function
+   * @returns This Lazy for chaining
+   */
+  tap(f: (value: T$1) => void): Lazy<T$1>;
+  /**
+   * Applies an effect function to the error if computation fails
+   * @param f - The effect function for errors
+   * @returns This Lazy for chaining
+   */
+  tapError(f: (error: unknown) => void): Lazy<T$1>;
+  /**
+   * Pattern matching on the Lazy value
+   * @param f - Function to apply to the computed value
+   * @returns The result of applying f to the computed value
+   */
+  fold<U>(f: (value: T$1) => U): U;
+  /**
+   * Pattern matching with success and failure handlers
+   * @param onFailure - Function to handle computation failure
+   * @param onSuccess - Function to handle successful computation
+   * @returns The result of the appropriate handler
+   */
+  foldWith<U>(onFailure: (error: unknown) => U, onSuccess: (value: T$1) => U): U;
+  /**
+   * Left fold operation
+   * @param z - Initial value
+   * @returns Function that takes an operator and applies it
+   */
+  foldLeft: <B>(z: B) => (op: (b: B, a: T$1) => B) => B;
+  /**
+   * Right fold operation
+   * @param z - Initial value
+   * @returns Function that takes an operator and applies it
+   */
+  foldRight: <B>(z: B) => (op: (a: T$1, b: B) => B) => B;
+  /**
+   * Pattern matching for the Lazy type
+   * @param patterns - Object with handler for Lazy pattern
+   * @returns The result of the matched handler
+   */
+  match<R$1>(patterns: {
+    Lazy: (value: T$1) => R$1;
+  }): R$1;
+  /**
+   * Creates a string representation of the Lazy
+   * @returns String representation showing evaluation status
+   */
+  toString(): string;
+  /**
+   * Converts the Lazy to a value object
+   * @returns Object representation of the Lazy with evaluation state
+   */
+  toValue(): {
+    _tag: "Lazy";
+    evaluated: boolean;
+    value?: T$1;
+  };
+}
+/**
+ * Creates a Lazy computation that defers evaluation until needed.
+ * Results are memoized after first evaluation.
+ *
+ * @example
+ * // Basic lazy evaluation
+ * const expensive = Lazy(() => {
+ *   console.log("Computing...")
+ *   return 42
+ * })
+ * // Nothing printed yet
+ * const result = expensive.orThrow() // Prints "Computing..." and returns 42
+ * const cached = expensive.orThrow() // Returns 42 without printing
+ *
+ * @example
+ * // Error handling
+ * const risky = Lazy(() => {
+ *   if (Math.random() > 0.5) throw new Error("Failed")
+ *   return "Success"
+ * })
+ * const safe = risky.orElse("Default") // Returns "Success" or "Default"
+ * const option = risky.toOption() // Some("Success") or None
+ * const either = risky.toEither() // Right("Success") or Left(Error)
+ *
+ * @example
+ * // Chaining computations
+ * const result = Lazy(() => 10)
+ *   .map(x => x * 2)
+ *   .flatMap(x => Lazy(() => x + 5))
+ *   .recover(err => 0)
+ *   .orThrow() // 25
+ *
+ * @example
+ * // Integration with functype
+ * const userOption = Option({ id: 1, name: "Alice" })
+ * const userName = Lazy.fromOption(userOption, () => ({ id: 0, name: "Anonymous" }))
+ *   .map(user => user.name)
+ *   .orThrow() // "Alice"
+ */
+declare const Lazy: (<T$1 extends Type>(thunk: () => T$1) => Lazy<T$1>) & {
+  /**
+   * Creates a Lazy from a thunk (deferred computation)
+   * @param thunk - Function that computes the value
+   * @returns A new Lazy instance
+   */
+  of: <T$1 extends Type>(thunk: () => T$1) => Lazy<T$1>;
+  /**
+   * Creates a Lazy from an immediate value
+   * @param value - The value to wrap
+   * @returns A new Lazy instance that returns the value
+   */
+  fromValue: <T$1 extends Type>(value: T$1) => Lazy<T$1>;
+  /**
+   * Creates a Lazy from an Option
+   * @param option - The Option to convert
+   * @param defaultThunk - Thunk to compute default value if Option is None
+   * @returns A new Lazy instance
+   */
+  fromOption: <T$1 extends Type>(option: Option<T$1>, defaultThunk: () => T$1) => Lazy<T$1>;
+  /**
+   * Creates a Lazy from a Try
+   * @param tryValue - The Try to convert
+   * @returns A new Lazy instance
+   */
+  fromTry: <T$1 extends Type>(tryValue: Try<T$1>) => Lazy<T$1>;
+  /**
+   * Creates a Lazy from an Either
+   * @param either - The Either to convert
+   * @returns A new Lazy instance
+   */
+  fromEither: <E, T$1 extends Type>(either: Either<E, T$1>) => Lazy<T$1>;
+  /**
+   * Creates a Lazy that will throw an error since promises need to be awaited first
+   * @param promise - The Promise to convert
+   * @returns A new Lazy instance that throws an error
+   */
+  fromPromise: <T$1 extends Type>(_promise: Promise<T$1>) => Lazy<T$1>;
+  /**
+   * Creates a failed Lazy that will throw when evaluated
+   * @param error - The error to throw
+   * @returns A new Lazy instance that throws the error
+   */
+  fail: <T$1 extends Type>(error: unknown) => Lazy<T$1>;
+};
+//#endregion
+//#region src/traversable/Traversable.d.ts
+/**
+ * Traversable typeclass for data structures that can be traversed through
+ */
+interface Traversable<A extends Type> extends AsyncMonad<A> {
+  get size(): number;
+  get isEmpty(): boolean;
+  contains(value: A): boolean;
+  reduce(f: (b: A, a: A) => A): A;
+  reduceRight(f: (b: A, a: A) => A): A;
+}
+//#endregion
+//#region src/map/Map.d.ts
+/**
+ * A traversable interface for map that excludes map and flatMap operations
+ */
+type SafeTraversable<K$1, V> = Omit<Traversable<Tuple<[K$1, V]>>, "map" | "flatMap" | "flatMapAsync" | "ap">;
+interface Map$1<K$1, V> extends SafeTraversable<K$1, V>, Collection<Tuple<[K$1, V]>>, Typeable<"Map">, Serializable<[K$1, V][]>, Pipe<[K$1, V][]>, Foldable<Tuple<[K$1, V]>>, Iterable<[K$1, V]> {
+  readonly _tag: "Map";
+  add(item: Tuple<[K$1, V]>): Map$1<K$1, V>;
+  remove(value: K$1): Map$1<K$1, V>;
+  map<U>(f: (value: V) => U): Map$1<K$1, U>;
+  ap<U>(ff: Map$1<K$1, (value: V) => U>): Map$1<K$1, U>;
+  flatMap<K2, V2>(f: (entry: Tuple<[K$1, V]>) => Iterable<[K2, V2]>): Map$1<K2, V2>;
+  flatMapAsync<U>(f: (value: V) => PromiseLike<Map$1<K$1, U>>): PromiseLike<Map$1<K$1, U>>;
+  get(key: K$1): Option<V>;
+  getOrElse(key: K$1, defaultValue: V): V;
+  orElse(key: K$1, alternative: Option<V>): Option<V>;
+  fold<U extends Type>(onEmpty: () => U, onValue: (value: Tuple<[K$1, V]>) => U): U;
+  foldLeft<B>(z: B): (op: (b: B, a: Tuple<[K$1, V]>) => B) => B;
+  foldRight<B>(z: B): (op: (a: Tuple<[K$1, V]>, b: B) => B) => B;
+  /**
+   * Pattern matches over the Map, applying a handler function based on whether it's empty
+   * @param patterns - Object with handler functions for Empty and NonEmpty variants
+   * @returns The result of applying the matching handler function
+   */
+  match<R$1>(patterns: {
+    Empty: () => R$1;
+    NonEmpty: (entries: Array<Tuple<[K$1, V]>>) => R$1;
+  }): R$1;
+  toValue(): {
+    _tag: "Map";
+    value: [K$1, V][];
+  };
+}
+declare const Map$1: (<K$1, V>(entries?: readonly (readonly [K$1, V])[] | IterableIterator<[K$1, V]> | null) => Map$1<K$1, V>) & {
+  /**
+   * Creates a Map from JSON string
+   * @param json - The JSON string
+   * @returns Map instance
+   */
+  fromJSON: <K$1, V>(json: string) => Map$1<K$1, V>;
+  /**
+   * Creates a Map from YAML string
+   * @param yaml - The YAML string
+   * @returns Map instance
+   */
+  fromYAML: <K$1, V>(yaml: string) => Map$1<K$1, V>;
+  /**
+   * Creates a Map from binary string
+   * @param binary - The binary string
+   * @returns Map instance
+   */
+  fromBinary: <K$1, V>(binary: string) => Map$1<K$1, V>;
+};
+//#endregion
+//#region src/map/shim.d.ts
+/**
+ * Type alias for the native JavaScript Map
+ * @interface
+ * @module Map
+ * @category Collections
+ */
+type ESMapType<K$1, V> = Map<K$1, V>;
+/**
+ * Reference to the native JavaScript Map
+ * @module Map
+ * @category Collections
+ */
+declare const ESMap: MapConstructor;
+//#endregion
+//#region src/matchable/Matchable.d.ts
+/**
+ * Pattern matching interface for functional data types.
+ *
+ * @typeParam A - The type of elements in the data structure
+ * @typeParam Tags - The type of tags used for pattern matching
+ */
+interface Matchable<A, Tags extends string = string> {
+  /**
+   * Pattern matches against this data structure, applying handlers for each variant based on tag.
+   * Similar to fold but with stronger type safety for tag-based variants.
+   *
+   * The return type is inferred from the pattern handlers when not explicitly specified.
+   *
+   * @param patterns - An object containing handler functions for each variant
+   * @returns The result of applying the matching handler function
+   */
+  match<R$1>(patterns: Record<Tags, (value: A) => R$1>): R$1;
+}
+/**
+ * Utility functions for working with Matchable data structures
+ */
+declare const MatchableUtils: {
+  /**
+   * Helper function to create a default case for pattern matching
+   *
+   * @param handler - The default handler function to apply
+   * @returns A function that always applies the default handler
+   */
+  default: <A, R$1>(handler: (value: A) => R$1) => (value: A) => R$1;
+  /**
+   * Helper function to create a match pattern that guards based on a predicate
+   *
+   * @param predicate - The predicate function for guarding
+   * @param handler - The handler function to apply if the predicate passes
+   * @returns A function that applies the handler only if the predicate passes
+   */
+  when: <A, R$1>(predicate: (value: A) => boolean, handler: (value: A) => R$1) => (value: A) => R$1 | undefined;
+};
+//#endregion
+//#region src/ref/Ref.d.ts
+/**
+ * A mutable reference container that holds a value of type A.
+ * This provides controlled mutability in a functional context.
+ *
+ * @example
+ * const counter = Ref(0)
+ * counter.get() // 0
+ * counter.set(5)
+ * counter.get() // 5
+ * counter.update(n => n + 1)
+ * counter.get() // 6
+ */
+interface Ref<A> {
+  /**
+   * Get the current value
+   */
+  get(): A;
+  /**
+   * Set a new value
+   */
+  set(value: A): void;
+  /**
+   * Update the value using a function
+   */
+  update(f: (current: A) => A): void;
+  /**
+   * Update and return the old value
+   */
+  getAndSet(value: A): A;
+  /**
+   * Update and return the new value
+   */
+  updateAndGet(f: (current: A) => A): A;
+  /**
+   * Update and return the old value
+   */
+  getAndUpdate(f: (current: A) => A): A;
+  /**
+   * Compare and swap - only updates if current value equals expected
+   */
+  compareAndSet(expected: A, newValue: A): boolean;
+  /**
+   * Modify the value and return a result
+   */
+  modify<B>(f: (current: A) => [A, B]): B;
+}
+declare const Ref: (<A extends Type>(initial: A) => Ref<A>) & {
+  /**
+   * Creates a Ref. Alias for Ref constructor.
+   * @param initial - The initial value
+   * @returns Ref instance
+   */
+  of: <A extends Type>(initial: A) => Ref<A>;
+};
+//#endregion
+//#region src/serialization/SerializationCompanion.d.ts
+/**
+ * Serialization result containing methods for different formats
+ */
+interface SerializationResult {
+  /** Serializes to JSON string */
+  toJSON: () => string;
+  /** Serializes to YAML string */
+  toYAML: () => string;
+  /** Serializes to base64-encoded binary string */
+  toBinary: () => string;
+}
+/**
+ * Creates a serializer for a simple tagged value
+ * @param tag - The type tag (e.g., "Some", "List", "Success")
+ * @param value - The value to serialize
+ * @returns Serialization methods
+ */
+declare const createSerializer: (tag: string, value: unknown) => SerializationResult;
+/**
+ * Creates a serializer for complex objects with custom serialization logic
+ * @param data - The data object to serialize (should include _tag)
+ * @returns Serialization methods
+ */
+declare const createCustomSerializer: (data: Record<string, unknown>) => SerializationResult;
+/**
+ * Generic deserializer from JSON
+ * @param json - The JSON string to parse
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Reconstructed instance
+ */
+declare const fromJSON: <T$1>(json: string, reconstructor: (parsed: {
+  _tag: string;
+  [key: string]: unknown;
+}) => T$1) => T$1;
+/**
+ * Generic deserializer from YAML (simple format)
+ * @param yaml - The YAML string to parse
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Reconstructed instance
+ */
+declare const fromYAML: <T$1>(yaml: string, reconstructor: (parsed: {
+  _tag: string;
+  [key: string]: unknown;
+}) => T$1) => T$1;
+/**
+ * Generic deserializer from binary (base64-encoded JSON)
+ * @param binary - The base64-encoded binary string
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Reconstructed instance
+ */
+declare const fromBinary: <T$1>(binary: string, reconstructor: (parsed: {
+  _tag: string;
+  [key: string]: unknown;
+}) => T$1) => T$1;
+/**
+ * Creates companion serialization methods for a type
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Companion methods object with fromJSON, fromYAML, and fromBinary
+ */
+declare const createSerializationCompanion: <T$1>(reconstructor: (parsed: {
+  _tag: string;
+  [key: string]: unknown;
+}) => T$1) => {
+  fromJSON: (json: string) => T$1;
+  fromYAML: (yaml: string) => T$1;
+  fromBinary: (binary: string) => T$1;
+};
+//#endregion
+//#region src/set/Set.d.ts
+interface Set<A> extends FunctypeCollection<A, "Set">, Collection<A> {
+  add: (value: A) => Set<A>;
+  remove: (value: A) => Set<A>;
+  contains: (value: A) => boolean;
+  has: (value: A) => boolean;
+  map: <B>(f: (a: A) => B) => Set<B>;
+  flatMap: <B>(f: (a: A) => Iterable<B>) => Set<B>;
+  filter: (p: (a: A) => boolean) => Set<A>;
+  filterNot: (p: (a: A) => boolean) => Set<A>;
+  fold: <U extends Type>(onEmpty: () => U, onValue: (value: A) => U) => U;
+  toList: () => List<A>;
+  toSet: () => Set<A>;
+  toArray: <B = A>() => B[];
+  toString: () => string;
+}
+declare const Set: (<A>(iterable?: Iterable<A>) => Set<A>) & {
+  /**
+   * Creates a Set from JSON string
+   * @param json - The JSON string
+   * @returns Set instance
+   */
+  fromJSON: <A>(json: string) => Set<A>;
+  /**
+   * Creates a Set from YAML string
+   * @param yaml - The YAML string
+   * @returns Set instance
+   */
+  fromYAML: <A>(yaml: string) => Set<A>;
+  /**
+   * Creates a Set from binary string
+   * @param binary - The binary string
+   * @returns Set instance
+   */
+  fromBinary: <A>(binary: string) => Set<A>;
+};
+//#endregion
+//#region src/valuable/Valuable.d.ts
+/**
+ * Parameters for creating a Valuable instance
+ */
+type ValuableParams<Tag extends string, T$1, V> = {
+  _tag: Tag;
+  impl: T$1;
+  value: V;
+};
+/**
+ * Represents a type that can extract its inner value. Creates a Valuable wrapper that adds value extraction capabilities.
+ * @param params - Configuration parameters
+ * @module Valuable
+ * @category Utilities
+ */
+declare function Valuable<Tag extends string, V, T$1 = object>(params: ValuableParams<Tag, T$1, V>): T$1 & {
+  toValue: () => {
+    _tag: Tag;
+    value: V;
+  };
+  _tag: Tag;
+};
+type Valuable<Tag extends string, V, T$1 = object> = Typeable<Tag, T$1> & {
+  toValue: () => {
+    _tag: Tag;
+    value: V;
+  };
+};
+//#endregion
+//#region src/stack/Stack.d.ts
+/**
+ * Stack data structure - Last In, First Out (LIFO)
+ * Implements the Traversable interface for working with ordered collections
+ */
+type Stack<A extends Type> = {
+  /**
+   * Push a value onto the top of the stack
+   * @param value - The value to push
+   * @returns A new Stack with the value added
+   */
+  push(value: A): Stack<A>;
+  /**
+   * Remove and return the top value from the stack
+   * @returns A tuple containing the new Stack and the value
+   */
+  pop(): [Stack<A>, Option<A>];
+  /**
+   * Return the top value without removing it
+   * @returns The top value wrapped in an Option
+   */
+  peek(): Option<A>;
+  /**
+   * Transforms each element in the stack using the provided function
+   * @param f - The mapping function
+   * @returns A new Stack with transformed elements
+   */
+  map<B extends Type>(f: (a: A) => B): Stack<B>;
+  /**
+   * Maps each element to a Stack and flattens the result
+   * @param f - The mapping function returning a Stack
+   * @returns A new flattened Stack
+   */
+  flatMap<B extends Type>(f: (a: A) => Stack<B>): Stack<B>;
+  /**
+   * Applies a Stack of functions to this Stack
+   * @param ff - Stack of functions to apply
+   * @returns A new Stack with applied functions
+   */
+  ap<B extends Type>(ff: Stack<(value: A) => B>): Stack<B>;
+  /**
+   * Maps each element to an async Stack and flattens the result
+   * @param f - The async mapping function returning a Stack
+   * @returns A promise of the new flattened Stack
+   */
+  flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Stack<B>>): PromiseLike<Stack<B>>;
+  /**
+   * Convert the stack to a List
+   * @returns A List containing all elements
+   */
+  toList(): List<A>;
+  /**
+   * Convert the stack to an array
+   * @returns An array of all elements
+   */
+  toArray(): A[];
+  /**
+   * Returns a string representation of the stack
+   * @returns A string representation
+   */
+  toString(): string;
+  /**
+   * Pattern matches over the Stack, applying a handler function based on whether it's empty
+   * @param patterns - Object with handler functions for Empty and NonEmpty variants
+   * @returns The result of applying the matching handler function
+   */
+  match<R$1>(patterns: {
+    Empty: () => R$1;
+    NonEmpty: (values: A[]) => R$1;
+  }): R$1;
+} & Traversable<A> & Valuable<"Stack", A[]> & Serializable<A> & Pipe<A[]> & Foldable<A> & Matchable<A[], "Empty" | "NonEmpty">;
+declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
+  /**
+   * Creates an empty stack
+   * @returns An empty Stack instance
+   */
+  empty: <A extends Type>() => Stack<A>;
+  /**
+   * Creates a Stack from a single value
+   * @param value - The value to create a stack with
+   * @returns A Stack with a single value
+   */
+  of: <A extends Type>(value: A) => Stack<A>;
+  /**
+   * Creates a Stack from JSON string
+   * @param json - The JSON string
+   * @returns Stack instance
+   */
+  fromJSON: <A>(json: string) => Stack<A>;
+  /**
+   * Creates a Stack from YAML string
+   * @param yaml - The YAML string
+   * @returns Stack instance
+   */
+  fromYAML: <A>(yaml: string) => Stack<A>;
+  /**
+   * Creates a Stack from binary string
+   * @param binary - The binary string
+   * @returns Stack instance
+   */
+  fromBinary: <A>(binary: string) => Stack<A>;
+};
+//#endregion
+//#region src/option/Option.d.ts
+/**
+ * Option type module
+ * @module Option
+ * @category Core
+ */
+/**
+ * The Option type represents a value that may or may not exist.
+ * It's used to handle potentially null or undefined values in a type-safe way.
+ * @typeParam T - The type of the value contained in the Option
+ */
+interface Option<T$1 extends Type> extends Functype<T$1, "Some" | "None">, Promisable<T$1>, Doable<T$1>, Reshapeable<T$1> {
+  /** The contained value (undefined for None) */
+  readonly value: T$1 | undefined;
+  /** Whether this Option contains no value */
+  isEmpty: boolean;
+  /**
+   * Returns true if this Option is a Some (contains a value)
+   * @returns true if this Option contains a value, false otherwise
+   */
+  isSome(): this is Option<T$1> & {
+    value: T$1;
+    isEmpty: false;
+  };
+  /**
+   * Returns true if this Option is a None (contains no value)
+   * @returns true if this Option is empty, false otherwise
+   */
+  isNone(): this is Option<T$1> & {
+    value: undefined;
+    isEmpty: true;
+  };
+  /**
+   * Returns the contained value or a default value if None
+   * @param defaultValue - The value to return if this Option is None
+   * @returns The contained value or defaultValue
+   */
+  orElse(defaultValue: T$1): T$1;
+  /**
+   * Returns the contained value or throws an error if None
+   * @param error - Optional custom error to throw. If not provided, throws a default error
+   * @returns The contained value
+   * @throws The specified error or a default error if the Option is None
+   */
+  orThrow(error?: Error): T$1;
+  /**
+   * Returns this Option if it contains a value, otherwise returns the alternative container
+   * @param alternative - The alternative Option to return if this is None
+   * @returns This Option or the alternative
+   */
+  or(alternative: Option<T$1>): Option<T$1>;
+  /**
+   * Returns the contained value or null if None
+   * @returns The contained value or null
+   */
+  orNull(): T$1 | null;
+  /**
+   * Returns the contained value or undefined if None
+   * @returns The contained value or undefined
+   */
+  orUndefined(): T$1 | undefined;
+  /**
+   * Maps the value inside the Option using the provided function
+   * @param f - The mapping function
+   * @returns A new Option containing the mapped value, or None if this Option is None
+   */
+  map<U extends Type>(f: (value: T$1) => U): Option<U>;
+  /**
+   * Applies a wrapped function to a wrapped value (Applicative pattern)
+   * @param ff - An Option containing a function from T to U
+   * @returns A new Option containing the result of applying the function
+   */
+  ap<U extends Type>(ff: Option<(value: T$1) => U>): Option<U>;
+  /**
+   * Returns this Option if it contains a value that satisfies the predicate, otherwise returns None
+   * @param predicate - The predicate function to test the value
+   * @returns This Option or None
+   */
+  filter(predicate: (value: T$1) => boolean): Option<T$1>;
+  /**
+   * Maps the value using a function that returns an Option
+   * @param f - The mapping function returning an Option
+   * @returns The result of applying f to the contained value, or None if this Option is None
+   */
+  flatMap<U extends Type>(f: (value: T$1) => Option<U>): Option<U>;
+  /**
+   * Maps the value using an async function that returns an Option
+   * @param f - The async mapping function returning an Option
+   * @returns Promise of the result of applying f to the contained value, or None if this Option is None
+   */
+  flatMapAsync<U extends Type>(f: (value: T$1) => Promise<Option<U>>): Promise<Option<U>>;
+  /**
+   * Applies a binary operator to a start value and the contained value
+   * @param f - The binary operator
+   * @returns The result of the reduction
+   */
+  reduce<U>(f: (acc: U, value: T$1) => U): U;
+  /**
+   * Applies a binary operator to the contained value and a start value
+   * @param f - The binary operator
+   * @returns The result of the reduction
+   */
+  reduceRight<U>(f: (acc: U, value: T$1) => U): U;
+  /**
+   * Pattern matches over the Option, applying onNone if None and onSome if Some
+   * @param onNone - Function to apply if the Option is None
+   * @param onSome - Function to apply if the Option has a value
+   * @returns The result of applying the appropriate function
+   */
+  fold<U>(onNone: () => U, onSome: (value: T$1) => U): U;
+  /**
+   * Left-associative fold using the provided zero value and operation
+   * @param z - Zero/identity value
+   * @returns A function that takes an operation to apply
+   */
+  foldLeft<B>(z: B): (op: (b: B, a: T$1) => B) => B;
+  /**
+   * Right-associative fold using the provided zero value and operation
+   * @param z - Zero/identity value
+   * @returns A function that takes an operation to apply
+   */
+  foldRight<B>(z: B): (op: (a: T$1, b: B) => B) => B;
+  /**
+   * Converts this Option to a List
+   * @returns A List containing the value if Some, or empty List if None
+   */
+  toList(): List<T$1>;
+  /**
+   * Checks if this Option contains the specified value
+   * @param value - The value to check for
+   * @returns true if this Option contains the value, false otherwise
+   */
+  contains(value: T$1): boolean;
+  /** The number of elements in this Option (0 or 1) */
+  size: number;
+  /**
+   * Converts this Option to an Either
+   * @param left - The value to use for Left if this Option is None
+   * @returns Either.Right with the contained value if Some, or Either.Left with left if None
+   */
+  toEither<E>(left: E): Either<E, T$1>;
+  /**
+   * Returns a string representation of this Option
+   * @returns A string representation
+   */
+  toString(): string;
+  /**
+   * Returns a simple object representation of this Option
+   * @returns An object with _tag and value properties
+   */
+  toValue(): {
+    _tag: "Some" | "None";
+    value: T$1;
+  };
+  /**
+   * Pattern matches over the Option, applying a handler function based on the variant
+   * @param patterns - Object with handler functions for Some and None variants
+   * @returns The result of applying the matching handler function
+   */
+  match<R$1>(patterns: {
+    Some: (value: T$1) => R$1;
+    None: () => R$1;
+  }): R$1;
+}
+/**
+ * Creates a Some variant of Option containing a value.
+ * @param value - The value to wrap in Some
+ * @returns A new Some instance containing the value
+ * @typeParam T - The type of the value
+ */
+declare const Some: <T$1 extends Type>(value: T$1) => Option<T$1>;
+/**
+ * Creates a None variant of Option representing absence of a value.
+ * @returns A new None instance
+ * @typeParam T - The type that would be contained if this was a Some
+ */
+declare const None: <T$1 extends Type>() => Option<T$1>;
+/**
+ * Safely wraps a value that might be null or undefined in an Option.
+ * Creates Some if the value is defined, None otherwise.
+ * @param value - The value to wrap (might be null/undefined)
+ * @returns Some(value) if value is defined, None otherwise
+ * @typeParam T - The type of the value
+ */
+declare const OptionConstructor: <T$1 extends Type>(value: T$1 | null | undefined) => Option<T$1>;
+declare const Option: (<T$1 extends Type>(value: T$1 | null | undefined) => Option<T$1>) & {
+  /**
+   * Creates an Option from any value. Alias for Option function.
+   * @param value - The value to wrap
+   * @returns Some(value) if value is defined, None otherwise
+   * @typeParam T - The type of the value
+   */
+  from: <T$1>(value: T$1) => Option<T$1>;
+  /**
+   * Returns a None instance. Alias for None function.
+   * @returns A None instance
+   * @typeParam T - The type that would be contained if this was a Some
+   */
+  none: <T$1>() => Option<T$1>;
+  /**
+   * Type guard to check if an Option is Some
+   * @param option - The Option to check
+   * @returns True if Option is Some
+   */
+  isSome: <T$1>(option: Option<T$1>) => option is Option<T$1> & {
+    value: T$1;
+    isEmpty: false;
+  };
+  /**
+   * Type guard to check if an Option is None
+   * @param option - The Option to check
+   * @returns True if Option is None
+   */
+  isNone: <T$1>(option: Option<T$1>) => option is Option<T$1> & {
+    value: undefined;
+    isEmpty: true;
+  };
+  /**
+   * Creates an Option from JSON string
+   * @param json - The JSON string
+   * @returns Option instance
+   */
+  fromJSON: <T$1>(json: string) => Option<T$1>;
+  /**
+   * Creates an Option from YAML string
+   * @param yaml - The YAML string
+   * @returns Option instance
+   */
+  fromYAML: <T$1>(yaml: string) => Option<T$1>;
+  /**
+   * Creates an Option from binary string
+   * @param binary - The binary string
+   * @returns Option instance
+   */
+  fromBinary: <T$1>(binary: string) => Option<T$1>;
+};
+//#endregion
+//#region src/list/List.d.ts
+interface List<A> extends FunctypeCollection<A, "List">, Doable<A>, Reshapeable<A> {
+  readonly length: number;
+  readonly [Symbol.iterator]: () => Iterator<A>;
+  map: <B>(f: (a: A) => B) => List<B>;
+  ap: <B>(ff: List<(value: A) => B>) => List<B>;
+  flatMap: <B>(f: (a: A) => Iterable<B>) => List<B>;
+  flatMapAsync: <B>(f: (a: A) => PromiseLike<Iterable<B>>) => PromiseLike<List<B>>;
+  filter<S extends A>(predicate: (a: A) => a is S): List<S>;
+  filter(predicate: (a: A) => unknown): List<A>;
+  filterNot: (p: (a: A) => boolean) => List<A>;
+  /** @internal */
+  filterType: <T$1 extends Typeable<string, unknown>>(tag: string) => List<T$1 & A>;
+  remove: (value: A) => List<A>;
+  removeAt: (index: number) => List<A>;
+  add: (item: A) => List<A>;
+  get: (index: number) => Option<A>;
+  concat: (other: List<A>) => List<A>;
+  /**
+   * Pattern matches over the List, applying a handler function based on whether it's empty
+   * @param patterns - Object with handler functions for Empty and NonEmpty variants
+   * @returns The result of applying the matching handler function
+   */
+  match<R$1>(patterns: {
+    Empty: () => R$1;
+    NonEmpty: (values: A[]) => R$1;
+  }): R$1;
+}
+declare const List: (<A>(values?: Iterable<A>) => List<A>) & {
+  /**
+   * Creates a List from JSON string
+   * @param json - The JSON string
+   * @returns List instance
+   */
+  fromJSON: <A>(json: string) => List<A>;
+  /**
+   * Creates a List from YAML string
+   * @param yaml - The YAML string
+   * @returns List instance
+   */
+  fromYAML: <A>(yaml: string) => List<A>;
+  /**
+   * Creates a List from binary string
+   * @param binary - The binary string
+   * @returns List instance
+   */
+  fromBinary: <A>(binary: string) => List<A>;
+};
+//#endregion
+//#region src/collections/index.d.ts
+/**
+ * Represents a collection with conversion capabilities
+ * @interface
+ * @module Collections
+ * @category Core
+ */
+interface Collection<A> {
+  toList(): List<A>;
+  toSet(): Set<A>;
+  toString(): string;
+}
+//#endregion
+//#region src/functype/Functype.d.ts
+/**
+ * Base interface for all functype data structures.
+ * This provides a standard contract with core functional programming traits.
+ *
+ * @typeParam A - The type of value contained in the functor
+ * @typeParam Tag - The type tag for pattern matching (e.g., "Some" | "None" for Option)
+ *
+ * @example
+ * ```typescript
+ * // Implementing FunctypeBase for a custom data structure
+ * class MyContainer<T> implements FunctypeBase<T, "Empty" | "Full"> {
+ *   // Implementation of all required methods...
+ * }
+ * ```
+ */
+interface FunctypeBase<A, Tag extends string = string> extends AsyncMonad<A>, Traversable<A>, Serializable<A>, Foldable<A>, Typeable<Tag>, ContainerOps<A> {
+  readonly _tag: Tag;
+}
+/**
+ * Interface for single-value containers like Option, Either, Try.
+ * Extends FunctypeBase with extraction methods and Pipe.
+ *
+ * @typeParam A - The type of value contained
+ * @typeParam Tag - The type tag for pattern matching
+ */
+interface Functype<A, Tag extends string = string> extends FunctypeBase<A, Tag>, Extractable<A>, Pipe<A>, Matchable<A, Tag> {
+  toValue(): {
+    _tag: Tag;
+    value: A;
+  };
+}
+/**
+ * A version of Functype for collection types that need iteration support.
+ * Extends FunctypeBase with Iterable protocol but without Extractable.
+ *
+ * @typeParam A - The element type of the collection
+ * @typeParam Tag - The type tag for pattern matching
+ */
+interface FunctypeCollection<A, Tag extends string = string> extends Omit<FunctypeBase<A, Tag>, "flatMapAsync" | "flatMap">, Iterable<A>, Pipe<A[]>, Collection<A>, CollectionOps<A, FunctypeCollection<A, Tag>> {
+  toValue(): {
+    _tag: Tag;
+    value: A[];
+  };
+  flatMap<B extends Type>(f: (value: A) => Iterable<B>): FunctypeCollection<B, Tag>;
+  flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Iterable<B>>): PromiseLike<FunctypeCollection<B, Tag>>;
+}
+//#endregion
+//#region src/either/Either.d.ts
+/**
+ * Either type module
+ * @module Either
+ * @category Core
+ */
+interface Either<L extends Type, R$1 extends Type> extends FunctypeBase<R$1, "Left" | "Right">, Promisable<R$1>, Doable<R$1>, Reshapeable<R$1>, Extractable<R$1> {
+  readonly _tag: "Left" | "Right";
+  value: L | R$1;
+  isLeft(): this is Either<L, R$1> & {
+    readonly _tag: "Left";
+    value: L;
+  };
+  isRight(): this is Either<L, R$1> & {
+    readonly _tag: "Right";
+    value: R$1;
+  };
+  orElse: (defaultValue: R$1) => R$1;
+  orThrow: (error?: Error) => R$1;
+  or(alternative: Either<L, R$1>): Either<L, R$1>;
+  orNull: () => R$1 | null;
+  orUndefined: () => R$1 | undefined;
+  readonly map: <U extends Type>(f: (value: R$1) => U) => Either<L, U>;
+  ap: <U extends Type>(ff: Either<L, (value: R$1) => U>) => Either<L, U>;
+  merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R$1, R1]>;
+  mapAsync: <U extends Type>(f: (value: R$1) => Promise<U>) => Promise<Either<L, U>>;
+  flatMap: <U extends Type>(f: (value: R$1) => Either<L, U>) => Either<L, U>;
+  flatMapAsync: <U extends Type>(f: (value: R$1) => Promise<Either<L, U>>) => Promise<Either<L, U>>;
+  toOption: () => Option<R$1>;
+  toList: () => List<R$1>;
+  toString: () => string;
+  [Symbol.iterator]: () => Iterator<R$1>;
+  yield: () => Generator<R$1, void, unknown>;
+  traverse: <U extends Type>(f: (value: R$1) => Either<L, U>) => Either<L, U[]>;
+  lazyMap: <U extends Type>(f: (value: R$1) => U) => Generator<Either<L, U>, void, unknown>;
+  tap: (f: (value: R$1) => void) => Either<L, R$1>;
+  tapLeft: (f: (value: L) => void) => Either<L, R$1>;
+  mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R$1>;
+  bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, fr: (value: R$1) => R2) => Either<L2, R2>;
+  fold: <T$1 extends Type>(onLeft: (value: L) => T$1, onRight: (value: R$1) => T$1) => T$1;
+  swap: () => Either<R$1, L>;
+  /**
+   * Pipes the value through the provided function based on whether this is a Left or Right
+   * @param onLeft - The function to apply if this is a Left
+   * @param onRight - The function to apply if this is a Right
+   * @returns The result of applying the appropriate function
+   */
+  pipeEither<U extends Type>(onLeft: (value: L) => U, onRight: (value: R$1) => U): U;
+  /**
+   * Pipes the Either value through the provided function
+   * @param f - The function to apply to the value (Left or Right)
+   * @returns The result of applying the function to the value
+   */
+  pipe<U extends Type>(f: (value: L | R$1) => U): U;
+  /**
+   * Pattern matches over the Either, applying a handler function based on the variant
+   * @param patterns - Object with handler functions for Left and Right variants
+   * @returns The result of applying the matching handler function
+   */
+  match<T$1>(patterns: {
+    Left: (value: L) => T$1;
+    Right: (value: R$1) => T$1;
+  }): T$1;
+  /**
+   * Returns the value and tag for inspection
+   */
+  toValue(): {
+    _tag: "Left" | "Right";
+    value: L | R$1;
+  };
+  /**
+   * Custom JSON serialization that excludes getter properties
+   */
+  toJSON(): {
+    _tag: "Left" | "Right";
+    value: L | R$1;
+  };
+}
+type TestEither<L extends Type, R$1 extends Type> = Either<L, R$1> & AsyncMonad<R$1>;
+declare const Right: <L extends Type, R$1 extends Type>(value: R$1) => Either<L, R$1>;
+declare const Left: <L extends Type, R$1 extends Type>(value: L) => Either<L, R$1>;
+declare const isRight: <L extends Type, R$1 extends Type>(either: Either<L, R$1>) => either is Either<L, R$1> & {
+  value: R$1;
+};
+declare const isLeft: <L extends Type, R$1 extends Type>(either: Either<L, R$1>) => either is Either<L, R$1> & {
+  value: L;
+};
+declare const tryCatch: <L extends Type, R$1 extends Type>(f: () => R$1, onError: (error: unknown) => L) => Either<L, R$1>;
+declare const TypeCheckRight: <L extends Type, R$1 extends Type>(value: R$1) => TestEither<L, R$1>;
+declare const TypeCheckLeft: <L extends Type, R$1 extends Type>(value: L) => TestEither<L, R$1>;
+declare const tryCatchAsync: <L extends Type, R$1 extends Type>(f: () => Promise<R$1>, onError: (error: unknown) => L) => Promise<Either<L, R$1>>;
+declare const Either: (<L extends Type, R$1 extends Type>(value: R$1 | L, isRight: boolean) => Either<L, R$1>) & {
+  /**
+   * Creates a Left instance
+   * @param value - The left value
+   * @returns Left Either
+   */
+  left: <L extends Type, R$1 extends Type>(value: L) => Either<L, R$1>;
+  /**
+   * Creates a Right instance
+   * @param value - The right value
+   * @returns Right Either
+   */
+  right: <L extends Type, R$1 extends Type>(value: R$1) => Either<L, R$1>;
+  /**
+   * Type guard to check if an Either is Right
+   * @param either - The Either to check
+   * @returns True if Either is Right
+   */
+  isRight: <L extends Type, R$1 extends Type>(either: Either<L, R$1>) => either is Either<L, R$1> & {
+    value: R$1;
+  };
+  /**
+   * Type guard to check if an Either is Left
+   * @param either - The Either to check
+   * @returns True if Either is Left
+   */
+  isLeft: <L extends Type, R$1 extends Type>(either: Either<L, R$1>) => either is Either<L, R$1> & {
+    value: L;
+  };
+  /**
+   * Combines an array of Eithers into a single Either containing an array
+   * @param eithers - Array of Either values
+   * @returns Either with array of values or first Left encountered
+   */
+  sequence: <L extends Type, R$1 extends Type>(eithers: Either<L, R$1>[]) => Either<L, R$1[]>;
+  /**
+   * Maps an array through a function that returns Either, then sequences the results
+   * @param arr - Array of values
+   * @param f - Function that returns Either
+   * @returns Either with array of results or first Left encountered
+   */
+  traverse: <L extends Type, R$1 extends Type, U extends Type>(arr: R$1[], f: (value: R$1) => Either<L, U>) => Either<L, U[]>;
+  /**
+   * Creates an Either from a nullable value
+   * @param value - The value that might be null or undefined
+   * @param leftValue - The value to use for Left if value is null/undefined
+   * @returns Right if value is not null/undefined, Left otherwise
+   */
+  fromNullable: <L extends Type, R$1 extends Type>(value: R$1 | null | undefined, leftValue: L) => Either<L, R$1>;
+  /**
+   * Creates an Either based on a predicate
+   * @param value - The value to test
+   * @param predicate - The predicate function
+   * @param leftValue - The value to use for Left if predicate fails
+   * @returns Right if predicate passes, Left otherwise
+   */
+  fromPredicate: <L extends Type, R$1 extends Type>(value: R$1, predicate: (value: R$1) => boolean, leftValue: L) => Either<L, R$1>;
+  /**
+   * Applicative apply - applies a wrapped function to a wrapped value
+   * @param eitherF - Either containing a function
+   * @param eitherV - Either containing a value
+   * @returns Either with function applied to value
+   */
+  ap: <L extends Type, R$1 extends Type, U extends Type>(eitherF: Either<L, (value: R$1) => U>, eitherV: Either<L, R$1>) => Either<L, U>;
+  /**
+   * Creates an Either from a Promise
+   * @param promise - The Promise to convert
+   * @param onRejected - Function to convert rejection reason to Left value
+   * @returns Promise that resolves to Either
+   */
+  fromPromise: <L, R$1>(promise: Promise<R$1>, onRejected: (reason: unknown) => L) => Promise<Either<L, R$1>>;
+  /**
+   * Creates an Either from JSON string
+   * @param json - The JSON string
+   * @returns Either instance
+   */
+  fromJSON: <L extends Type, R$1 extends Type>(json: string) => Either<L, R$1>;
+  /**
+   * Creates an Either from YAML string
+   * @param yaml - The YAML string
+   * @returns Either instance
+   */
+  fromYAML: <L extends Type, R$1 extends Type>(yaml: string) => Either<L, R$1>;
+  /**
+   * Creates an Either from binary string
+   * @param binary - The binary string
+   * @returns Either instance
+   */
+  fromBinary: <L extends Type, R$1 extends Type>(binary: string) => Either<L, R$1>;
+};
+//#endregion
+//#region src/do/index.d.ts
+type OptionLike = {
+  _tag: "Some" | "None";
+  isSome(): boolean;
+  get(): unknown;
+};
+type EitherLike = {
+  _tag: "Left" | "Right";
+  isLeft(): boolean;
+  isRight(): boolean;
+  value: unknown;
+};
+type ListLike = {
+  _tag: "List";
+  toArray(): unknown[];
+};
+type TryLike = {
+  _tag: "Success" | "Failure";
+  isSuccess(): boolean;
+  get(): unknown;
+};
+/**
+ * Executes a generator-based monadic comprehension
+ * Returns the same monad type as the first yielded monad (Scala semantics)
+ *
+ * - Option comprehensions return Option (None on short-circuit)
+ * - Either comprehensions return Either (Left with error on short-circuit)
+ * - List comprehensions return List (empty or cartesian product)
+ * - Try comprehensions return Try (Failure with error on short-circuit)
+ *
+ * Type Inference Notes:
+ * - TypeScript infers the correct return type for homogeneous comprehensions
+ * - For mixed monad types, TypeScript returns a union type
+ * - Use DoTyped<T> or type assertions for mixed scenarios
+ *
+ * @example
+ * ```typescript
+ * // Option comprehension returns Option:
+ * const result = Do(function* () {
+ *   const x = yield* $(Option(5));
+ *   const y = yield* $(Option(10));
+ *   return x + y;
+ * });
+ * // result: Option(15)
+ *
+ * // Either comprehension returns Either:
+ * const result = Do(function* () {
+ *   const x = yield* $(Right(5));
+ *   const y = yield* $(Left("error"));
+ *   return x + y;
+ * });
+ * // result: Left("error") - error is preserved
+ *
+ * // List comprehension returns List with cartesian product:
+ * const result = Do(function* () {
+ *   const x = yield* $(List([1, 2]));
+ *   const y = yield* $(List([3, 4]));
+ *   return x + y;
+ * });
+ * // result: List([4, 5, 5, 6])
+ *
+ * // Mixed types - use type assertion or DoTyped:
+ * const result = Do(function* () {
+ *   const x = yield* $(Option(5));
+ *   const y = yield* $(Right<string, number>(10));
+ *   return x + y;
+ * }) as Option<number>;
+ * // result: Option(15)
+ * ```
+ *
+ * @param gen - Generator function that yields monads and returns a result
+ * @returns The same monad type as the first yield
+ */
+declare function Do<T$1>(gen: () => Generator<OptionLike, T$1, unknown>): Option<T$1>;
+declare function Do<L, R$1>(gen: () => Generator<EitherLike, R$1, unknown>): Either<L, R$1>;
+declare function Do<T$1>(gen: () => Generator<ListLike, T$1, unknown>): List<T$1>;
+declare function Do<T$1>(gen: () => Generator<TryLike, T$1, unknown>): Try<T$1>;
+declare function Do<T$1>(gen: () => Generator<OptionLike | EitherLike | ListLike | TryLike, T$1, unknown>): Reshapeable<T$1>;
+declare function Do<T$1>(gen: () => Generator<unknown, T$1, unknown>): unknown;
+/**
+ * Executes an async generator-based monadic comprehension
+ * Returns the same monad type as the first yielded monad
+ *
+ * @example
+ * ```typescript
+ * const result = await DoAsync(async function* () {
+ *   const user = yield* $(await fetchUser(id));       // Promise<Option<User>> → User
+ *   const profile = yield* $(await getProfile(user)); // Promise<Either<Error, Profile>> → Profile
+ *   return { user, profile };
+ * });
+ * // result type matches first yield
+ * ```
+ *
+ * @param gen - Async generator function that yields monads/promises and returns a result
+ * @returns Promise of the same monad type as first yield
+ */
+declare function DoAsync<T$1>(gen: () => AsyncGenerator<OptionLike, T$1, unknown>): Promise<Option<T$1>>;
+declare function DoAsync<L, R$1>(gen: () => AsyncGenerator<EitherLike, R$1, unknown>): Promise<Either<L, R$1>>;
+declare function DoAsync<T$1>(gen: () => AsyncGenerator<ListLike, T$1, unknown>): Promise<List<T$1>>;
+declare function DoAsync<T$1>(gen: () => AsyncGenerator<TryLike, T$1, unknown>): Promise<Try<T$1>>;
+declare function DoAsync<T$1>(gen: () => AsyncGenerator<OptionLike | EitherLike | ListLike | TryLike, T$1, unknown>): Promise<Reshapeable<T$1>>;
+declare function DoAsync<T$1>(gen: () => AsyncGenerator<unknown, T$1, unknown>): Promise<unknown>;
+/**
+ * Helper function to check if a value implements the Doable interface
+ * @param value - Value to check
+ * @returns True if the value implements Doable
+ */
+declare function isDoCapable<T$1>(value: unknown): value is Doable<T$1>;
+/**
+ * Manually unwrap a monad using the Doable interface
+ * Useful for testing or when you need to unwrap outside of a Do-comprehension
+ *
+ * @param monad - Monad to unwrap
+ * @returns The unwrapped value
+ * @throws Error if the monad cannot be unwrapped
+ */
+declare function unwrap<T$1>(monad: Doable<T$1>): T$1;
+/**
+ * Type helper for Do-notation generators.
+ * Provides better type hints in IDEs.
+ *
+ * @example
+ * ```typescript
+ * const result = Do(function* (): DoGenerator<number> {
+ *   const x = yield* $(List([1, 2]))  // x is still unknown but return type is clear
+ *   const y = yield* $(List([3, 4]))
+ *   return x + y
+ * })
+ * ```
+ */
+type DoGenerator<T$1, TYield = unknown> = Generator<TYield, T$1, unknown>;
+/**
+ * Extracts values from monads in Do-notation with type inference.
+ * The '$' symbol is the universal extraction operator in functional programming.
+ *
+ * @example
+ * ```typescript
+ * const result = Do(function* () {
+ *   const x = yield* $(Option(5))        // x: number
+ *   const y = yield* $(List([1, 2, 3]))  // y: number (for cartesian product)
+ *   const name = yield* $(Right("Alice")) // name: string
+ *   return `${name}: ${x + y}`
+ * })
+ * ```
+ *
+ * @param monad - Any monad that can be unwrapped (Option, Either, List, Try, etc.)
+ * @returns A generator that yields the monad and returns its extracted value
+ */
+declare function $<T$1>(monad: Option<T$1>): Generator<Option<T$1>, T$1, T$1>;
+declare function $<L, R$1>(monad: Either<L, R$1>): Generator<Either<L, R$1>, R$1, R$1>;
+declare function $<T$1>(monad: List<T$1>): Generator<List<T$1>, T$1, T$1>;
+declare function $<T$1>(monad: Try<T$1>): Generator<Try<T$1>, T$1, T$1>;
+declare function $<T$1>(monad: Doable<T$1>): Generator<Doable<T$1>, T$1, T$1>;
+declare function $<M>(monad: M): Generator<M, InferYieldType<M>, InferYieldType<M>>;
+type InferYieldType<M> = M extends {
+  isSome(): boolean;
+  get(): infer T;
+} ? T : M extends {
+  isRight(): boolean;
+  value: infer R;
+} ? R : M extends {
+  toArray(): (infer T)[];
+} ? T : M extends {
+  isSuccess(): boolean;
+  get(): infer T;
+} ? T : M extends Doable<infer T> ? T : unknown;
+declare const NoneError: (message?: string) => Error;
+interface LeftErrorType<L> extends Error {
+  value: L;
+}
+declare const LeftError: <L>(value: L, message?: string) => LeftErrorType<L>;
+declare const EmptyListError: (message?: string) => Error;
+interface FailureErrorType extends Error {
+  cause: Error;
+}
+declare const FailureError: (cause: Error, message?: string) => FailureErrorType;
+//#endregion
+export { EitherKind as $, isCompanion as $t, OptionConstructor as A, Ok as At, fromBinary as B, createCancellationTokenSource as Bt, Functype as C, ContainerOps as Cn, formatError as Ct, List as D, DoResult as Dn, CancellationToken as Dt, Collection as E, isExtractable as En, Async as Et, Set as F, TaskMetadata as Ft, MatchableUtils as G, NAME as Gt, fromYAML as H, ErrorContext as Ht, SerializationResult as I, TaskOutcome as It, Map$1 as J, Base as Jt, ESMap as K, Throwable as Kt, createCustomSerializer as L, TaskParams as Lt, Stack as M, TaggedThrowable as Mt, Valuable as N, Task as Nt, None as O, Doable as On, CancellationTokenSource as Ot, ValuableParams as P, TaskFailure as Pt, Identity as Q, InstanceType as Qt, createSerializationCompanion as R, TaskResult as Rt, tryCatchAsync as S, CollectionOps as Sn, createErrorSerializer as St, FunctypeCollection as T, Extractable as Tn, safeStringify as Tt, Ref as U, FPromise as Ut, fromJSON as V, isTaggedThrowable as Vt, Matchable as W, FPromiseCompanion as Wt, Traversable as X, Cond as Xt, SafeTraversable as Y, Match as Yt, Lazy as Z, CompanionMethods as Zt, TypeCheckLeft as _, Promisable as _n, ParseError as _t, EmptyListError as a, IntegerNumber as an, UniversalContainer as at, isRight as b, Functor as bn, ErrorWithTaskInfo as bt, LeftError as c, PatternString as cn, FormValidation as ct, isDoCapable as d, UUID as dn, Validator as dt, Companion as en, HKT as et, unwrap as f, UrlString as fn, ErrorCode as ft, TestEither as g, TypeNames as gn, TypedErrorContext as gt, Right as h, Try as hn, TypedError as ht, DoGenerator as i, ISO8601Date as in, TryKind as it, Some as j, Sync as jt, Option as k, Err as kt, LeftErrorType as l, PositiveInteger as ln, Validation as lt, Left as m, ValidatedBrandCompanion as mn, ErrorStatus as mt, Do as n, BoundedString as nn, ListKind as nt, FailureError as o, NonEmptyString as on, FoldableUtils as ot, Either as p, ValidatedBrand as pn, ErrorMessage as pt, ESMapType as q, ThrowableType as qt, DoAsync as r, EmailAddress as rn, OptionKind as rt, FailureErrorType as s, NonNegativeNumber as sn, FieldValidation as st, $ as t, BoundedNumber as tn, Kind as tt, NoneError as u, PositiveNumber as un, ValidationRule as ut, TypeCheckRight as v, Applicative as vn, ErrorChainElement as vt, FunctypeBase as w, LazyList as wn, formatStackTrace as wt, tryCatch as x, Monad as xn, TaskErrorInfo as xt, isLeft as y, AsyncMonad as yn, ErrorFormatterOptions as yt, createSerializer as z, TaskSuccess as zt };
+//# sourceMappingURL=index-Bnjlo4cT.d.ts.map