functype 0.18.0 → 0.20.0

package/dist/Either-Ccg0S1uS.d.ts

@@ -1,1015 +0,0 @@
-import { T as Type, P as Pipe, a as Typeable, S as Serializable, F as Foldable } from './Typeable-DiGVtDnq.js';
-
-/**
- * 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> = {
-    ok: true;
-    value: T;
-} | {
-    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> {
-    doUnwrap(): DoResult<T>;
-}
-
-/**
- * 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 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;
-}
-/**
- * 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 extends Type> extends Unsafe<T> {
-    /**
-     * 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): T;
-    /**
-     * 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>): Extractable<T>;
-    /**
-     * Returns the contained value or null
-     * @returns The contained value or null
-     */
-    orNull(): T | null;
-    /**
-     * Returns the contained value or undefined
-     * @returns The contained value or undefined
-     */
-    orUndefined(): T | undefined;
-}
-/**
- * Type guard to check if a value implements Extractable
- */
-declare function isExtractable<T extends Type>(value: unknown): value is Extractable<T>;
-
-/**
- * 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[];
-}
-
-/**
- * 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>>;
-}
-
-/**
- * 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>;
-}
-
-/**
- * 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;
-    toValue(): {
-        _tag: TypeNames;
-        value: T | Error;
-    };
-}
-declare const Try: (<T>(f: () => T) => 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>;
-};
-
-/**
- * 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 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>;
-    /**
-     * 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>;
-    /**
-     * 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>;
-    /**
-     * 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>;
-}
-
-/**
- * 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>;
-/**
- * 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;
-}
-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>;
-};
-
-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>;
-    /**
-     * 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 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>;
-};
-
-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>;
-};
-
-/**
- * Represents a collection with conversion capabilities
- * @interface
- * @module Collections
- * @category Core
- */
-interface Collection<A> {
-    toList(): List<A>;
-    toSet(): Set<A>;
-    toString(): string;
-}
-
-/**
- * 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>(patterns: Record<Tags, (value: A) => R>): R;
-}
-/**
- * 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>(handler: (value: A) => R) => (value: A) => R;
-    /**
-     * 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>(predicate: (value: A) => boolean, handler: (value: A) => R) => (value: A) => R | undefined;
-};
-
-/**
- * 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;
-}
-
-/**
- * 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>>;
-}
-
-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>>;
-/**
- * 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;
-    };
-}
-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>;
-};
-
-export { type AsyncMonad as A, type Collection as C, type DoResult as D, Either as E, type FunctypeBase as F, List as L, type Matchable as M, None as N, Option as O, type Promisable as P, Right as R, Some as S, Try as T, type Extractable as a, type Doable as b, type Traversable as c, type TestEither as d, Left as e, isLeft as f, TypeCheckRight as g, TypeCheckLeft as h, isRight as i, tryCatchAsync as j, isExtractable as k, type Functype as l, type FunctypeCollection as m, MatchableUtils as n, OptionConstructor as o, Set as p, type TypeNames as q, type CollectionOps as r, type ContainerOps as s, tryCatch as t, type Applicative as u, type Functor as v, type Monad as w, type Reshapeable as x };