functype 0.8.81 → 0.8.83

package/dist/Either-CncND8cm.d.ts

@@ -0,0 +1,709 @@
+import { T as Type, a as Typeable } from './Typeable-BBXrKPTY.js';
+
+/**
+ * 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"> {
+    /** The contained value (undefined for None) */
+    readonly value: T | undefined;
+    /** Whether this Option contains no value */
+    isEmpty: boolean;
+    /**
+     * Extracts the value if present
+     * @throws Error if the Option is None
+     * @returns The contained value
+     */
+    get(): T;
+    /**
+     * 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
+     */
+    getOrElse(defaultValue: T): T;
+    /**
+     * Returns the contained value or throws a specified error if None
+     * @param error - The error to throw if this Option is None
+     * @returns The contained value
+     * @throws The specified error if the Option is None
+     */
+    getOrThrow(error: Error): T;
+    /**
+     * Returns this Option if it contains a value, otherwise returns the alternative
+     * @param alternative - The alternative Option to return if this is None
+     * @returns This Option or the alternative
+     */
+    orElse(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>;
+    /**
+     * 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"> {
+    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>;
+    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>() => readonly 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;
+}
+
+/**
+ * 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 safe extraction methods.
+ */
+interface Extractable<T extends Type> {
+    /**
+     * Extracts the value unsafely
+     * @throws Error if the container is empty
+     * @returns The contained value
+     */
+    get(): T;
+    /**
+     * Returns the contained value or a default value
+     * @param defaultValue - The value to return if extraction fails
+     * @returns The contained value or defaultValue
+     */
+    getOrElse(defaultValue: T): T;
+    /**
+     * Returns the contained value or throws an error
+     * @param error - Optional error to throw (implementations may have defaults)
+     * @returns The contained value
+     * @throws The specified error if extraction fails
+     */
+    getOrThrow(error?: Error): T;
+    /**
+     * Returns this container if it has a value, otherwise returns the alternative
+     * @param alternative - The alternative container
+     * @returns This container or the alternative
+     */
+    orElse(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;
+}
+
+/**
+ * Foldable type class represents data structures that can be folded to a summary value.
+ *
+ * @typeParam A - The type of elements in the data structure
+ */
+interface Foldable<A> {
+    /**
+     * Pattern matches over the structure, applying specific handlers for each variant
+     * @param onEmpty - Function to apply if the structure is empty or has no value
+     * @param onValue - Function to apply if the structure has a value
+     * @returns The result of applying the appropriate function
+     */
+    fold<B>(onEmpty: () => B, onValue: (value: A) => B): B;
+    /**
+     * 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: A) => 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: A, b: B) => B) => B;
+}
+
+/**
+ * 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;
+};
+
+/**
+ * Pipe interface for functional data structures
+ * @typeParam T - The type of value to pipe
+ */
+interface Pipe<T extends Type> {
+    /**
+     * Pipes the value through the provided function
+     * @param f - The function to apply to the value
+     * @returns The result of applying the function to the value
+     * @typeParam U - The return type of the function
+     */
+    pipe<U extends Type>(f: (value: T) => U): U;
+}
+
+/**
+ * Methods for different serialization formats
+ */
+interface SerializationMethods<T> {
+    toJSON(): string;
+    toYAML(): string;
+    toBinary(): string;
+}
+interface Serializable<T> {
+    serialize(): SerializationMethods<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>(): readonly 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>>;
+}
+
+/**
+ * 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">, PromiseLike<R> {
+    readonly _tag: "Left" | "Right";
+    value: L | R;
+    isLeft: () => boolean;
+    isRight: () => boolean;
+    get: () => R;
+    getOrElse: (defaultValue: R) => R;
+    getOrThrow: (error?: Error) => R;
+    orElse(alternative: Either<L, R>): Either<L, R>;
+    orNull: () => R | null;
+    orUndefined: () => R | undefined;
+    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: {
+    sequence: <L extends Type, R extends Type>(eithers: Either<L, R>[]) => Either<L, R[]>;
+    traverse: <L extends Type, R extends Type, U extends Type>(arr: R[], f: (value: R) => Either<L, U>) => Either<L, U[]>;
+    fromNullable: <L extends Type, R extends Type>(value: R | null | undefined, leftValue: L) => Either<L, R>;
+    fromPredicate: <L extends Type, R extends Type>(value: R, predicate: (value: R) => boolean, leftValue: L) => Either<L, R>;
+    ap: <L extends Type, R extends Type, U extends Type>(eitherF: Either<L, (value: R) => U>, eitherV: Either<L, R>) => Either<L, U>;
+    fromPromise: <L, R>(promise: Promise<R>, onRejected: (reason: unknown) => L) => Promise<Either<L, R>>;
+    fromJSON: <L extends Type, R extends Type>(json: string) => Either<L, R>;
+    fromYAML: <L extends Type, R extends Type>(yaml: string) => Either<L, R>;
+    fromBinary: <L extends Type, R extends Type>(binary: string) => Either<L, R>;
+};
+
+export { type AsyncMonad as A, type Collection as C, Either as E, type Foldable as F, List as L, type Matchable as M, None as N, Option as O, type Pipe as P, Right as R, type Serializable as S, type Traversable as T, type FunctypeBase as a, type Extractable as b, type TestEither as c, Left as d, isLeft as e, TypeCheckRight as f, TypeCheckLeft as g, tryCatchAsync as h, isRight as i, type Functype as j, type FunctypeCollection as k, MatchableUtils as l, Some as m, OptionConstructor as n, type SerializationMethods as o, Set as p, type CollectionOps as q, type ContainerOps as r, type Applicative as s, tryCatch as t, type Functor as u, type Monad as v };