functype 0.49.0 → 0.50.0

package/dist/{Functype-rgysbeU6.d.ts → index-OdnROQtM.d.ts}

@@ -1,10 +1,5 @@
-import { Brand } from "./branded/index.js";
-import { a as Serializable, c as Foldable, l as Type, n as Typeable, s as Pipe } from "./Typeable-lfO2nRVW.js";
-import { Try } from "./try/index.js";
-import { Set } from "./set/index.js";
-import { Option } from "./option/index.js";
-import { List } from "./list/index.js";
-import { Either } from "./either/index.js";
+import { t as Brand } from "./Brand-BJIRbUKB.js";
+import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple, u as Type } from "./Tuple-DmywDCE9.js";
 
 //#region src/error/ParseError.d.ts
 declare const ParseError: (message?: string) => Error & {
@@ -416,6 +411,126 @@ interface Promisable<A extends Type> {
   toPromise(): Promise<A>;
 }
 //#endregion
+//#region src/try/Try.d.ts
+/**
+ * Possible types of Try instances
+ */
+type TypeNames = "Success" | "Failure";
+interface Try<T> extends FunctypeBase<T, TypeNames>, Extractable<T>, Pipe<T>, Promisable<T>, Doable<T>, Reshapeable<T> {
+  readonly _tag: TypeNames;
+  readonly error: Error | undefined;
+  isSuccess(): this is Try<T> & {
+    readonly _tag: "Success";
+    error: undefined;
+  };
+  isFailure(): this is Try<T> & {
+    readonly _tag: "Failure";
+    error: Error;
+  };
+  orElse: (defaultValue: T) => T;
+  orThrow: (error?: Error) => T;
+  or: (alternative: Try<T>) => Try<T>;
+  orNull: () => T | null;
+  orUndefined: () => T | undefined;
+  toOption: () => Option<T>;
+  toEither: <E extends Type>(leftValue: E) => Either<E, T>;
+  toList: () => List<T>;
+  toTry: () => Try<T>;
+  map: <U>(f: (value: T) => U) => Try<U>;
+  ap: <U>(ff: Try<(value: T) => U>) => Try<U>;
+  flatMap: <U>(f: (value: T) => Try<U>) => Try<U>;
+  flatMapAsync: <U>(f: (value: T) => 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) => 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>(patterns: {
+    Success: (value: T) => R;
+    Failure: (error: Error) => R;
+  }): R;
+  /**
+   * Recovers from a Failure by applying a function to the error, returning a new Try
+   * @param f - Function to apply to the error to produce a recovery value
+   * @returns Success with the recovery value if Failure, otherwise this
+   */
+  recover: (f: (error: Error) => T) => Try<T>;
+  /**
+   * Recovers from a Failure by applying a function that returns a new Try
+   * @param f - Function to apply to the error to produce a new Try
+   * @returns The result of f if Failure, otherwise this
+   */
+  recoverWith: (f: (error: Error) => Try<T>) => Try<T>;
+  toValue(): {
+    _tag: TypeNames;
+    value: T | Error;
+  };
+}
+declare const Try: (<T>(f: () => T) => Try<T>) & {
+  /**
+   * Creates a Success directly without needing a callback
+   * @param value - The success value
+   * @returns Try containing the value as Success
+   */
+  success: <T>(value: T) => Try<T>;
+  /**
+   * Creates a Failure directly without needing to throw
+   * @param error - The error (string or Error instance)
+   * @returns Try containing the error as Failure
+   */
+  failure: <T>(error: Error | string) => Try<T>;
+  /**
+   * Creates a Try from a Promise, resolving to Success or Failure
+   * @param promise - The promise to convert
+   * @returns Promise resolving to a Try
+   */
+  fromPromise: <T>(promise: Promise<T>) => Promise<Try<T>>;
+  /**
+   * Type guard to check if a Try is Success
+   * @param tryValue - The Try to check
+   * @returns True if Try is Success
+   */
+  isSuccess: <T>(tryValue: Try<T>) => tryValue is Try<T> & {
+    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>(tryValue: Try<T>) => tryValue is Try<T> & {
+    readonly _tag: "Failure";
+    error: Error;
+  };
+  /**
+   * Creates a Try from JSON string
+   * @param json - The JSON string
+   * @returns Try instance
+   */
+  fromJSON: <T>(json: string) => Try<T>;
+  /**
+   * Creates a Try from YAML string
+   * @param yaml - The YAML string
+   * @returns Try instance
+   */
+  fromYAML: <T>(yaml: string) => Try<T>;
+  /**
+   * Creates a Try from binary string
+   * @param binary - The binary string
+   * @returns Try instance
+   */
+  fromBinary: <T>(binary: string) => Try<T>;
+};
+//#endregion
 //#region src/reshapeable/Reshapeable.d.ts
 /**
  * Interface for types that can be reshaped (converted) between different monadic containers.
@@ -3435,6 +3550,73 @@ interface Traversable<A extends Type> extends AsyncMonad<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, V> = Omit<Traversable<Tuple<[K, V]>>, "map" | "flatMap" | "flatMapAsync" | "ap">;
+interface Map$1<K, V> extends SafeTraversable<K, V>, Collection<Tuple<[K, V]>>, Typeable<"Map">, Serializable<[K, V][]>, Pipe<[K, V][]>, Foldable<Tuple<[K, V]>>, Iterable<[K, V]> {
+  readonly [Symbol.toStringTag]: string;
+  readonly _tag: "Map";
+  add(item: Tuple<[K, V]>): Map$1<K, V>;
+  remove(value: K): Map$1<K, V>;
+  map<U>(f: (value: V) => U): Map$1<K, U>;
+  ap<U>(ff: Map$1<K, (value: V) => U>): Map$1<K, U>;
+  flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => Iterable<[K2, V2]>): Map$1<K2, V2>;
+  flatMapAsync<U>(f: (value: V) => PromiseLike<Map$1<K, U>>): PromiseLike<Map$1<K, U>>;
+  get(key: K): Option<V>;
+  getOrElse(key: K, defaultValue: V): V;
+  orElse(key: K, alternative: Option<V>): Option<V>;
+  fold<U extends Type>(onEmpty: () => U, onValue: (value: Tuple<[K, V]>) => U): U;
+  foldLeft<B>(z: B): (op: (b: B, a: Tuple<[K, V]>) => B) => B;
+  foldRight<B>(z: B): (op: (a: Tuple<[K, 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>(patterns: {
+    Empty: () => R;
+    NonEmpty: (entries: Array<Tuple<[K, V]>>) => R;
+  }): R;
+  toValue(): {
+    _tag: "Map";
+    value: [K, V][];
+  };
+}
+declare const Map$1: (<K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null) => Map$1<K, V>) & {
+  /**
+   * Creates an empty Map
+   * Returns a singleton instance for efficiency
+   * @returns An empty Map instance
+   */
+  empty: <K, V>() => Map$1<K, V>;
+  /**
+   * Creates a Map from variadic key-value pair arguments
+   * @param entries - Key-value pairs to create map from
+   * @returns A Map containing the entries
+   */
+  of: <K, V>(...entries: [K, V][]) => Map$1<K, V>;
+  /**
+   * Creates a Map from JSON string
+   * @param json - The JSON string
+   * @returns Map instance
+   */
+  fromJSON: <K, V>(json: string) => Map$1<K, V>;
+  /**
+   * Creates a Map from YAML string
+   * @param yaml - The YAML string
+   * @returns Map instance
+   */
+  fromYAML: <K, V>(yaml: string) => Map$1<K, V>;
+  /**
+   * Creates a Map from binary string
+   * @param binary - The binary string
+   * @returns Map instance
+   */
+  fromBinary: <K, V>(binary: string) => Map$1<K, V>;
+};
+//#endregion
 //#region src/map/shim.d.ts
 /**
  * Type alias for the native JavaScript Map
@@ -3615,6 +3797,55 @@ declare const createSerializationCompanion: <T>(reconstructor: (parsed: {
   fromBinary: (binary: string) => T;
 };
 //#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 an empty Set
+   * Returns a singleton instance for efficiency
+   * @returns An empty Set instance
+   */
+  empty: <A extends Type>() => Set<A>;
+  /**
+   * Creates a Set from variadic arguments
+   * @param values - Values to create set from
+   * @returns A Set containing the unique values
+   */
+  of: <A extends Type>(...values: 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
@@ -3748,6 +3979,323 @@ declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
   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 extends Type> extends Functype<T, "Some" | "None">, Promisable<T>, Doable<T>, Reshapeable<T> {
+  /** The contained value (undefined for None) */
+  readonly value: T | 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> & {
+    value: T;
+    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> & {
+    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): T;
+  /**
+   * 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;
+  /**
+   * 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>): Option<T>;
+  /**
+   * Returns the contained value or null if None
+   * @returns The contained value or null
+   */
+  orNull(): T | null;
+  /**
+   * Returns the contained value or undefined if None
+   * @returns The contained value or undefined
+   */
+  orUndefined(): T | 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) => 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) => 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) => boolean): Option<T>;
+  /**
+   * 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) => 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) => 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) => 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) => 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) => 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) => 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, 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>;
+  /**
+   * 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): 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>;
+  /**
+   * 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;
+  };
+  /**
+   * 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>(patterns: {
+    Some: (value: T) => R;
+    None: () => R;
+  }): R;
+}
+/**
+ * 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 extends Type>(value: T) => Option<T>;
+/**
+ * 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 extends Type>() => Option<T>;
+/**
+ * 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 extends Type>(value: T | null | undefined) => Option<T>;
+declare const Option: (<T extends Type>(value: T | null | undefined) => Option<T>) & {
+  /**
+   * 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>(value: T) => Option<T>;
+  /**
+   * 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>() => Option<T>;
+  /**
+   * Type guard to check if an Option is Some
+   * @param option - The Option to check
+   * @returns True if Option is Some
+   */
+  isSome: <T>(option: Option<T>) => option is Option<T> & {
+    value: T;
+    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>(option: Option<T>) => option is Option<T> & {
+    value: undefined;
+    isEmpty: true;
+  };
+  /**
+   * Creates an Option from JSON string
+   * @param json - The JSON string
+   * @returns Option instance
+   */
+  fromJSON: <T>(json: string) => Option<T>;
+  /**
+   * Creates an Option from YAML string
+   * @param yaml - The YAML string
+   * @returns Option instance
+   */
+  fromYAML: <T>(yaml: string) => Option<T>;
+  /**
+   * Creates an Option from binary string
+   * @param binary - The binary string
+   * @returns Option instance
+   */
+  fromBinary: <T>(binary: string) => Option<T>;
+};
+//#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 extends Typeable<string, unknown>>(tag: string) => List<T & 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>;
+  take: (n: number) => List<A>;
+  takeWhile: (p: (a: A) => boolean) => List<A>;
+  takeRight: (n: number) => List<A>;
+  get last(): A | undefined;
+  get lastOption(): Option<A>;
+  get tail(): List<A>;
+  get init(): List<A>;
+  reverse: () => List<A>;
+  indexOf: (value: A) => number;
+  prepend: (item: A) => List<A>;
+  distinct: () => List<A>;
+  sorted: (compareFn?: (a: A, b: A) => number) => List<A>;
+  sortBy: <B>(f: (a: A) => B, compareFn?: (a: B, b: B) => number) => List<A>;
+  zip: <B>(other: List<B>) => List<[A, B]>;
+  zipWithIndex: () => List<[A, number]>;
+  groupBy: <K>(f: (a: A) => K) => globalThis.Map<K, List<A>>;
+  partition: (p: (a: A) => boolean) => [List<A>, List<A>];
+  span: (p: (a: A) => boolean) => [List<A>, List<A>];
+  slice: (start: number, end: number) => 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>(patterns: {
+    Empty: () => R;
+    NonEmpty: (values: A[]) => R;
+  }): R;
+}
+declare const List: (<A>(values?: Iterable<A>) => List<A>) & {
+  /**
+   * Creates an empty List
+   * Returns a singleton instance for efficiency
+   * @returns An empty List instance
+   */
+  empty: <A extends Type>() => List<A>;
+  /**
+   * Creates a List from variadic arguments
+   * @param values - Values to create list from
+   * @returns A List containing the values
+   */
+  of: <A extends Type>(...values: 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
@@ -3810,4 +4358,363 @@ interface FunctypeCollection<A, Tag extends string = string> extends Omit<Functy
   flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Iterable<B>>): PromiseLike<FunctypeCollection<B, Tag>>;
 }
 //#endregion
-export { Validation as $, UrlString as $t, UIO as A, isTaggedThrowable as At, Tag as B, isCompanion as Bt, TestClockTag as C, TaskFailure as Ct, RIO as D, TaskResult as Dt, InterruptedError as E, TaskParams as Et, Exit as F, Match as Ft, Kind as G, ISO8601Date as Gt, Identity as H, BoundedNumber as Ht, ExitTag as I, UntypedMatch as It, TryKind as J, NonNegativeNumber as Jt, ListKind as K, IntegerNumber as Kt, Context as L, Cond as Lt, LayerError as M, Throwable as Mt, LayerInput as N, ThrowableType as Nt, Task as O, TaskSuccess as Ot, LayerOutput as P, Base as Pt, FormValidation as Q, UUID as Qt, ContextServices as R, CompanionMethods as Rt, TestClock as S, Task$1 as St, IO as T, TaskOutcome as Tt, EitherKind as U, BoundedString as Ut, TagService as V, Companion as Vt, HKT as W, EmailAddress as Wt, FoldableUtils as X, PositiveInteger as Xt, UniversalContainer as Y, PatternString as Yt, FieldValidation as Z, PositiveNumber as Zt, MatchableUtils as _, CancellationTokenSource as _t, Stack as a, AsyncMonad as an, TypedError as at, Traversable as b, Sync as bt, SerializationResult as c, CollectionOps as cn, ErrorFormatterOptions as ct, createSerializer as d, Extractable as dn, createErrorSerializer as dt, ValidatedBrand as en, ValidationRule as et, fromBinary as f, isExtractable as fn, formatError as ft, Matchable as g, CancellationToken as gt, Ref as h, ParseError as hn, Async as ht, Collection as i, Applicative as in, ErrorStatus as it, Layer as j, NAME as jt, TimeoutError as k, createCancellationTokenSource as kt, createCustomSerializer as l, ContainerOps as ln, ErrorWithTaskInfo as lt, fromYAML as m, Doable as mn, safeStringify as mt, FunctypeBase as n, Reshapeable as nn, ErrorCode as nt, Valuable as o, Functor as on, TypedErrorContext as ot, fromJSON as p, DoResult as pn, formatStackTrace as pt, OptionKind as q, NonEmptyString as qt, FunctypeCollection as r, Promisable as rn, ErrorMessage as rt, ValuableParams as s, Monad as sn, ErrorChainElement as st, Functype as t, ValidatedBrandCompanion as tn, Validator as tt, createSerializationCompanion as u, LazyList as un, TaskErrorInfo as ut, ESMap as v, Err as vt, TestContext as w, TaskMetadata as wt, Lazy as x, TaggedThrowable as xt, ESMapType as y, Ok as yt, HasService as z, InstanceType as zt };
+//#region src/either/Either.d.ts
+/**
+ * Either type module
+ * @module Either
+ * @category Core
+ */
+interface Either<L extends Type, R extends Type> extends FunctypeBase<R, "Left" | "Right">, Promisable<R>, Doable<R>, Reshapeable<R>, Extractable<R> {
+  readonly _tag: "Left" | "Right";
+  value: L | R;
+  isLeft(): this is Either<L, R> & {
+    readonly _tag: "Left";
+    value: L;
+  };
+  isRight(): this is Either<L, R> & {
+    readonly _tag: "Right";
+    value: R;
+  };
+  orElse: (defaultValue: R) => R;
+  orThrow: (error?: Error) => R;
+  or(alternative: Either<L, R>): Either<L, R>;
+  orNull: () => R | null;
+  orUndefined: () => R | undefined;
+  readonly map: <U extends Type>(f: (value: R) => U) => Either<L, U>;
+  ap: <U extends Type>(ff: Either<L, (value: R) => U>) => Either<L, U>;
+  merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R, R1]>;
+  mapAsync: <U extends Type>(f: (value: R) => Promise<U>) => Promise<Either<L, U>>;
+  flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>;
+  flatMapAsync: <U extends Type>(f: (value: R) => Promise<Either<L, U>>) => Promise<Either<L, U>>;
+  toOption: () => Option<R>;
+  toList: () => List<R>;
+  toString: () => string;
+  [Symbol.iterator]: () => Iterator<R>;
+  yield: () => Generator<R, void, unknown>;
+  traverse: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U[]>;
+  lazyMap: <U extends Type>(f: (value: R) => U) => Generator<Either<L, U>, void, unknown>;
+  tap: (f: (value: R) => void) => Either<L, R>;
+  tapLeft: (f: (value: L) => void) => Either<L, R>;
+  mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R>;
+  bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, fr: (value: R) => R2) => Either<L2, R2>;
+  fold: <T extends Type>(onLeft: (value: L) => T, onRight: (value: R) => T) => T;
+  swap: () => Either<R, 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) => 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) => 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>(patterns: {
+    Left: (value: L) => T;
+    Right: (value: R) => T;
+  }): T;
+  /**
+   * Returns the value and tag for inspection
+   */
+  toValue(): {
+    _tag: "Left" | "Right";
+    value: L | R;
+  };
+  /**
+   * Custom JSON serialization that excludes getter properties
+   */
+  toJSON(): {
+    _tag: "Left" | "Right";
+    value: L | R;
+  };
+}
+type TestEither<L extends Type, R extends Type> = Either<L, R> & AsyncMonad<R>;
+declare const Right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
+declare const Left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
+declare const isRight: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
+  value: R;
+};
+declare const isLeft: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
+  value: L;
+};
+declare const tryCatch: <L extends Type, R extends Type>(f: () => R, onError: (error: unknown) => L) => Either<L, R>;
+declare const TypeCheckRight: <L extends Type, R extends Type>(value: R) => TestEither<L, R>;
+declare const TypeCheckLeft: <L extends Type, R extends Type>(value: L) => TestEither<L, R>;
+declare const tryCatchAsync: <L extends Type, R extends Type>(f: () => Promise<R>, onError: (error: unknown) => L) => Promise<Either<L, R>>;
+declare const Either: (<L extends Type, R extends Type>(value: R | L, isRight: boolean) => Either<L, R>) & {
+  /**
+   * Creates a Left instance
+   * @param value - The left value
+   * @returns Left Either
+   */
+  left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
+  /**
+   * Creates a Right instance
+   * @param value - The right value
+   * @returns Right Either
+   */
+  right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
+  /**
+   * 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 extends Type>(either: Either<L, R>) => either is Either<L, R> & {
+    value: R;
+  };
+  /**
+   * 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 extends Type>(either: Either<L, R>) => either is Either<L, R> & {
+    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 extends Type>(eithers: Either<L, R>[]) => Either<L, R[]>;
+  /**
+   * 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 extends Type, U extends Type>(arr: R[], f: (value: R) => 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 extends Type>(value: R | null | undefined, leftValue: L) => Either<L, R>;
+  /**
+   * 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 extends Type>(value: R, predicate: (value: R) => boolean, leftValue: L) => Either<L, R>;
+  /**
+   * 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 extends Type, U extends Type>(eitherF: Either<L, (value: R) => U>, eitherV: Either<L, R>) => 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>(promise: Promise<R>, onRejected: (reason: unknown) => L) => Promise<Either<L, R>>;
+  /**
+   * Creates an Either from JSON string
+   * @param json - The JSON string
+   * @returns Either instance
+   */
+  fromJSON: <L extends Type, R extends Type>(json: string) => Either<L, R>;
+  /**
+   * Creates an Either from YAML string
+   * @param yaml - The YAML string
+   * @returns Either instance
+   */
+  fromYAML: <L extends Type, R extends Type>(yaml: string) => Either<L, R>;
+  /**
+   * Creates an Either from binary string
+   * @param binary - The binary string
+   * @returns Either instance
+   */
+  fromBinary: <L extends Type, R extends Type>(binary: string) => Either<L, R>;
+};
+//#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>(gen: () => Generator<OptionLike, T, unknown>): Option<T>;
+declare function Do<L, R>(gen: () => Generator<EitherLike, R, unknown>): Either<L, R>;
+declare function Do<T>(gen: () => Generator<ListLike, T, unknown>): List<T>;
+declare function Do<T>(gen: () => Generator<TryLike, T, unknown>): Try<T>;
+declare function Do<T>(gen: () => Generator<OptionLike | EitherLike | ListLike | TryLike, T, unknown>): Reshapeable<T>;
+declare function Do<T>(gen: () => Generator<unknown, T, 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>(gen: () => AsyncGenerator<OptionLike, T, unknown>): Promise<Option<T>>;
+declare function DoAsync<L, R>(gen: () => AsyncGenerator<EitherLike, R, unknown>): Promise<Either<L, R>>;
+declare function DoAsync<T>(gen: () => AsyncGenerator<ListLike, T, unknown>): Promise<List<T>>;
+declare function DoAsync<T>(gen: () => AsyncGenerator<TryLike, T, unknown>): Promise<Try<T>>;
+declare function DoAsync<T>(gen: () => AsyncGenerator<OptionLike | EitherLike | ListLike | TryLike, T, unknown>): Promise<Reshapeable<T>>;
+declare function DoAsync<T>(gen: () => AsyncGenerator<unknown, T, 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>(value: unknown): value is Doable<T>;
+/**
+ * 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>(monad: Doable<T>): T;
+/**
+ * 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, TYield = unknown> = Generator<TYield, T, 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>(monad: Option<T>): Generator<Option<T>, T, T>;
+declare function $<L, R>(monad: Either<L, R>): Generator<Either<L, R>, R, R>;
+declare function $<T>(monad: List<T>): Generator<List<T>, T, T>;
+declare function $<T>(monad: Try<T>): Generator<Try<T>, T, T>;
+declare function $<T>(monad: Doable<T>): Generator<Doable<T>, T, T>;
+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 { TestClockTag as $, TaskFailure as $t, OptionConstructor as A, ValidatedBrand as An, ValidationRule as At, fromBinary as B, ContainerOps as Bn, TaskErrorInfo as Bt, Functype as C, NonEmptyString as Cn, OptionKind as Ct, List as D, PositiveNumber as Dn, FieldValidation as Dt, Collection as E, PositiveInteger as En, FoldableUtils as Et, Set as F, Applicative as Fn, TypedError as Ft, MatchableUtils as G, Doable as Gn, Async as Gt, fromYAML as H, Extractable as Hn, formatError as Ht, SerializationResult as I, AsyncMonad as In, TypedErrorContext as It, Map$1 as J, Err as Jt, ESMap as K, ParseError as Kn, CancellationToken as Kt, createCustomSerializer as L, Functor as Ln, ErrorChainElement as Lt, Stack as M, Try as Mn, ErrorCode as Mt, Valuable as N, TypeNames as Nn, ErrorMessage as Nt, None as O, UUID as On, FormValidation as Ot, ValuableParams as P, Promisable as Pn, ErrorStatus as Pt, TestClock as Q, Task$1 as Qt, createSerializationCompanion as R, Monad as Rn, ErrorFormatterOptions as Rt, tryCatchAsync as S, IntegerNumber as Sn, ListKind as St, FunctypeCollection as T, PatternString as Tn, UniversalContainer as Tt, Ref as U, isExtractable as Un, formatStackTrace as Ut, fromJSON as V, LazyList as Vn, createErrorSerializer as Vt, Matchable as W, DoResult as Wn, safeStringify as Wt, Traversable as X, Sync as Xt, SafeTraversable as Y, Ok as Yt, Lazy as Z, TaggedThrowable as Zt, TypeCheckLeft as _, Companion as _n, TagService as _t, EmptyListError as a, createCancellationTokenSource as an, TimeoutError as at, isRight as b, EmailAddress as bn, HKT as bt, LeftError as c, Throwable as cn, LayerError as ct, isDoCapable as d, Match as dn, Exit as dt, TaskMetadata as en, TestContext as et, unwrap as f, UntypedMatch as fn, ExitTag as ft, TestEither as g, isCompanion as gn, Tag as gt, Right as h, InstanceType as hn, HasService as ht, DoGenerator as i, TaskSuccess as in, Task as it, Some as j, ValidatedBrandCompanion as jn, Validator as jt, Option as k, UrlString as kn, Validation as kt, LeftErrorType as l, ThrowableType as ln, LayerInput as lt, Left as m, CompanionMethods as mn, ContextServices as mt, Do as n, TaskParams as nn, InterruptedError as nt, FailureError as o, isTaggedThrowable as on, UIO as ot, Either as p, Cond as pn, Context as pt, ESMapType as q, CancellationTokenSource as qt, DoAsync as r, TaskResult as rn, RIO as rt, FailureErrorType as s, NAME as sn, Layer as st, $ as t, TaskOutcome as tn, IO as tt, NoneError as u, Base as un, LayerOutput as ut, TypeCheckRight as v, BoundedNumber as vn, Identity as vt, FunctypeBase as w, NonNegativeNumber as wn, TryKind as wt, tryCatch as x, ISO8601Date as xn, Kind as xt, isLeft as y, BoundedString as yn, EitherKind as yt, createSerializer as z, CollectionOps as zn, ErrorWithTaskInfo as zt };