functype 0.8.61 → 0.8.62

package/dist/option/index.d.ts

@@ -1,870 +1 @@
-import { T as Typeable, a as Type, F as Functor, V as Valuable, A as AsyncFunctor, E as ExtractTag, b as Tuple } from '../Tuple-GXgoHfiN.js';
-import '../branded/index.js';
-
-/**
- * Creates a function-object hybrid similar to Scala's companion objects.
- * This utility allows creating TypeScript function objects with attached methods,
- * mimicking Scala's class + companion object pattern without using classes.
- *
- * @param object The main function that will be invoked when the object is called
- * @param companion Additional static methods to attach to the function
- * @returns A function with the attached methods
- *
- * @example
- * const greet = (name: string) => `Hello, ${name}!`;
- * const methods = {
- *   formal: (name: string) => `Good day, ${name}.`,
- *   casual: (name: string) => `Hey ${name}!`
- * };
- * const Greeter = createCompanionObject(greet, methods);
- *
- * // Usage:
- * Greeter("World"); // Hello, World!
- * Greeter.formal("Sir"); // Good day, Sir.
- * Greeter.casual("Friend"); // Hey Friend!
- */
-declare function Companion<ObjectF extends object, CompanionF extends object>(object: ObjectF, companion: CompanionF): ObjectF & CompanionF;
-
-/**
- * Base Object from which most other objects inherit
- * @param type
- * @param body
- * @constructor
- */
-declare function Base<T>(type: string, body: T): T & {
-    toString(): string;
-    _tag: string;
-};
-
-declare const NAME: "Throwable";
-type ThrowableType = Error & Typeable<typeof NAME> & {
-    readonly data?: unknown;
-    readonly cause?: Error;
-};
-declare class Throwable extends Error implements ThrowableType {
-    readonly _tag: typeof NAME;
-    readonly data?: unknown;
-    readonly cause?: Error;
-    protected constructor(message: string, options?: {
-        data?: unknown | undefined;
-        cause?: Error | undefined;
-        stack?: string | undefined;
-    });
-    static apply(srcError: unknown, data?: unknown): ThrowableType;
-}
-
-/**
- * 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>;
-/**
- * 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
- */
-type Option<T extends Type> = {
-    /** Tag identifying if this is a Some or None variant */
-    readonly _tag: "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;
-    /**
-     * 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>;
-    /**
-     * 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;
-    };
-} & (Traversable<T> & Functor<T> & Typeable<"Some" | "None"> & Valuable<"Some" | "None", T> & AsyncFunctor<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 Option: {
-    <T extends Type>(value: T | null | undefined): Option<T>;
-    from<T>(value: T): Option<T>;
-    none<T>(): Option<T>;
-};
-
-type IterableType<A extends Type> = {
-    count(p: (x: A) => boolean): number;
-    find(p: (a: A) => boolean): Option<A>;
-    forEach(f: (a: A) => void): void;
-    drop(n: number): IterableType<A>;
-    dropRight(n: number): IterableType<A>;
-    dropWhile(p: (a: A) => boolean): IterableType<A>;
-    exists(p: (a: A) => boolean): boolean;
-    filter(p: (a: A) => boolean): IterableType<A>;
-    filterNot(p: (a: A) => boolean): IterableType<A>;
-    flatten<B>(): IterableType<B>;
-    reduce(f: (b: A, a: A) => A): A;
-    reduceRight(f: (b: A, a: A) => A): A;
-    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
-    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
-    get head(): A | undefined;
-    get headOption(): Option<A>;
-    get isEmpty(): boolean;
-    map<B extends Type>(f: (a: A) => B): IterableType<B>;
-    flatMap<B extends Type>(f: (a: A) => IterableType<B>): IterableType<B>;
-    get size(): number;
-    toArray<B = A>(): readonly B[];
-} & Iterable<A> & Functor<A> & AsyncFunctor<A>;
-
-type Converters<A> = {
-    toList(): List<A>;
-    toSet(): Set<A>;
-    toString(): string;
-};
-type Collection<A> = Converters<A>;
-
-type Set<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) => IterableType<B>) => Set<B>;
-    toList: () => List<A>;
-    toSet: () => Set<A>;
-    toString: () => string;
-} & IterableType<A> & Collection<A> & Typeable<"Set">;
-declare const Set: <A>(iterable?: Iterable<A> | IterableType<A>) => Set<A>;
-
-type List<A> = {
-    readonly length: number;
-    readonly [Symbol.iterator]: () => Iterator<A>;
-    map: <B>(f: (a: A) => B) => List<B>;
-    flatMap: <B>(f: (a: A) => IterableType<B>) => List<B>;
-    flatMapAsync: <B>(f: (a: A) => PromiseLike<IterableType<B>>) => PromiseLike<List<B>>;
-    forEach: (f: (a: A) => void) => void;
-    count: (p: (x: A) => boolean) => number;
-    exists: (p: (a: A) => boolean) => boolean;
-    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>;
-    find: <T extends A = A>(predicate: (a: A) => boolean, tag?: ExtractTag<T>) => Option<T>;
-    readonly head: A | undefined;
-    readonly headOption: Option<A>;
-    readonly isEmpty: boolean;
-    toArray: <B = A>() => B[];
-    reduce: (f: (prev: A, curr: A) => A) => A;
-    reduceRight: (f: (prev: A, curr: A) => A) => A;
-    foldLeft: <B>(z: B) => (op: (b: B, a: A) => B) => B;
-    foldRight: <B>(z: B) => (op: (a: A, b: B) => B) => B;
-    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>;
-    toList: () => List<A>;
-    toSet: () => Set<A>;
-    toString: () => string;
-    toValue: () => {
-        _tag: "List";
-        value: A[];
-    };
-    drop: (n: number) => List<A>;
-    dropRight: (n: number) => List<A>;
-    dropWhile: (p: (a: A) => boolean) => List<A>;
-    flatten: <B>() => List<B>;
-} & IterableType<A> & AsyncFunctor<A> & Typeable<"List">;
-declare const List: <A>(values?: Iterable<A>) => List<A>;
-
-type TestEither<L extends Type, R extends Type> = Either<L, R> & Functor<R> & AsyncFunctor<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
- */
-type Either<L extends Type, R extends Type> = {
-    readonly _tag: "Left" | "Right";
-    value: L | R;
-    isLeft: () => boolean;
-    isRight: () => boolean;
-    getOrElse: (defaultValue: R) => R;
-    getOrThrow: () => R;
-    map: <U extends Type>(f: (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>;
-} & Typeable<"Left" | "Right"> & Valuable<"Left" | "Right", L | R> & PromiseLike<R> & AsyncFunctor<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>>;
-};
-
-/**
- * Error context information that provides additional metadata about errors.
- * This context is passed to error mapping functions to provide more information
- * about the error that occurred.
- *
- * @property originalError - The original error that was thrown
- * @property stack - The stack trace of the error, if available
- * @property timestamp - The timestamp when the error occurred
- */
-type ErrorContext = {
-    originalError: unknown;
-    stack?: string;
-    timestamp: number;
-};
-/**
- * Static utility methods for FPromise using the Companion pattern.
- * These methods provide factory functions and utilities for working with FPromises.
- */
-declare const FPromiseCompanion: {
-    /**
-     * Creates an FPromise that resolves to the provided value.
-     *
-     * @template T - The type of the value
-     * @template E - The type of the error (defaults to never since this FPromise won't reject)
-     * @param value - The value to resolve with
-     * @returns An FPromise that resolves to the value
-     *
-     * @example
-     * const promise = FPromise.resolve(42)
-     * // promise resolves to 42
-     */
-    resolve: <T, E = never>(value: T | PromiseLike<T>) => FPromise<T, E>;
-    /**
-     * Creates an FPromise that rejects with the provided reason.
-     *
-     * @template T - The type of the value (which will never be produced)
-     * @template E - The type of the error
-     * @param reason - The reason for rejection
-     * @returns An FPromise that rejects with the reason
-     *
-     * @example
-     * const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
-     * // promise rejects with Error("Something went wrong")
-     */
-    reject: <T, E = unknown>(reason: E) => FPromise<T, E>;
-    /**
-     * Creates an FPromise from a regular Promise.
-     *
-     * @template T - The type of the value
-     * @template E - The type of the error
-     * @param promise - The Promise to convert
-     * @returns An FPromise that resolves or rejects with the same value or error
-     *
-     * @example
-     * const promise = FPromise.from(fetch("https://api.example.com/data"))
-     * // promise is an FPromise that resolves or rejects based on the fetch result
-     */
-    from: <T, E = unknown>(promise: Promise<T>) => FPromise<T, E>;
-    /**
-     * Creates an FPromise from an Either.
-     * If the Either is a Right, the FPromise resolves with the Right value.
-     * If the Either is a Left, the FPromise rejects with the Left value.
-     *
-     * @template L - The type of the Left value (error)
-     * @template R - The type of the Right value (success)
-     * @param either - The Either to convert
-     * @returns An FPromise that resolves or rejects based on the Either
-     *
-     * @example
-     * const either = Right<Error, number>(42)
-     * const promise = FPromise.fromEither(either)
-     * // promise resolves to 42
-     */
-    fromEither: <L, R>(either: Either<L, R>) => FPromise<R, L>;
-    /**
-     * Runs multiple FPromises in parallel and returns an array of results.
-     * Similar to Promise.all, this will reject if any of the promises reject.
-     *
-     * @template T - The type of the values
-     * @template E - The type of the error
-     * @param promises - An array of FPromises, Promises, or values
-     * @returns An FPromise that resolves to an array of results
-     *
-     * @example
-     * const promises = [FPromise.resolve(1), FPromise.resolve(2), 3]
-     * const result = await FPromise.all(promises).toPromise()
-     * // result is [1, 2, 3]
-     */
-    all: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T> | T>) => FPromise<T[], E>;
-    /**
-     * Like Promise.allSettled, returns results of all promises whether they succeed or fail.
-     * This will always resolve, never reject.
-     *
-     * @template T - The type of the values
-     * @template E - The type of the errors
-     * @param promises - An array of FPromises or Promises
-     * @returns An FPromise that resolves to an array of Either results
-     *
-     * @example
-     * const promises = [FPromise.resolve(1), FPromise.reject<number, Error>(new Error("Failed"))]
-     * const result = await FPromise.allSettled(promises).toPromise()
-     * // result is [Right(1), Left(Error("Failed"))]
-     */
-    allSettled: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<Array<Either<E, T>>, never>;
-    /**
-     * Like Promise.race, returns the first promise to settle (either resolve or reject).
-     *
-     * @template T - The type of the values
-     * @template E - The type of the errors
-     * @param promises - An array of FPromises or Promises
-     * @returns An FPromise that resolves or rejects with the result of the first promise to settle
-     *
-     * @example
-     * const slow = FPromise.resolve(1).tap(() => new Promise(r => setTimeout(r, 100)))
-     * const fast = FPromise.resolve(2).tap(() => new Promise(r => setTimeout(r, 50)))
-     * const result = await FPromise.race([slow, fast]).toPromise()
-     * // result is 2
-     */
-    race: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
-    /**
-     * Like Promise.any, returns the first promise to fulfill.
-     * This will only reject if all promises reject.
-     *
-     * @template T - The type of the values
-     * @template E - The type of the errors
-     * @param promises - An array of FPromises or Promises
-     * @returns An FPromise that resolves with the first promise to fulfill or rejects if all promises reject
-     *
-     * @example
-     * const promises = [
-     *   FPromise.reject<number, Error>(new Error("First failed")),
-     *   FPromise.resolve(2),
-     *   FPromise.reject<number, Error>(new Error("Third failed"))
-     * ]
-     * const result = await FPromise.any(promises).toPromise()
-     * // result is 2
-     */
-    any: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
-    /**
-     * Retries an operation with exponential backoff.
-     * This is useful for operations that may fail temporarily, such as network requests.
-     *
-     * @template T - The type of the value
-     * @template E - The type of the error
-     * @param operation - A function that returns an FPromise
-     * @param options - Configuration options for the retry
-     * @param options.maxRetries - Maximum number of retry attempts
-     * @param options.baseDelay - Base delay in milliseconds (default: 100)
-     * @param options.shouldRetry - Function that determines whether to retry based on the error (default: always retry)
-     * @returns An FPromise that resolves when the operation succeeds or rejects after all retries fail
-     *
-     * @example
-     * const operation = () => {
-     *   if (Math.random() > 0.8) {
-     *     return FPromise.resolve("Success!")
-     *   }
-     *   return FPromise.reject<string, Error>(new Error("Temporary failure"))
-     * }
-     *
-     * const result = await FPromise.retryWithBackoff(operation, {
-     *   maxRetries: 3,
-     *   baseDelay: 100,
-     *   shouldRetry: (error) => error.message === "Temporary failure"
-     * }).toPromise()
-     */
-    retryWithBackoff: <T, E = unknown>(operation: () => FPromise<T, E>, options: {
-        maxRetries: number;
-        baseDelay?: number;
-        shouldRetry?: (error: E, attempt: number) => boolean;
-    }) => FPromise<T, E>;
-};
-/**
- * FPromise is a functional wrapper around JavaScript's Promise with enhanced error handling.
- * It implements the Functor and AsyncFunctor interfaces, providing map and flatMap operations
- * for functional composition.
- *
- * FPromise adds several features not available in standard Promises:
- * - Generic error typing for better type safety
- * - Error recovery mechanisms (recover, recoverWith, recoverWithF)
- * - Error filtering and categorization
- * - Side effect methods (tap, tapError)
- * - Error context preservation
- * - Conversion to/from Either for more functional error handling
- *
- * @template T - The type of the value that the FPromise resolves to
- * @template E - The type of the error that the FPromise may reject with (defaults to unknown)
- */
-/**
- * FPromise type that defines the function signature and methods
- */
-interface FPromise<T extends Type, E extends Type = unknown> extends PromiseLike<T> {
-    readonly _tag: "FPromise";
-    tap: (f: (value: T) => void) => FPromise<T, E>;
-    mapError: <E2>(f: (error: E, context: ErrorContext) => E2) => FPromise<T, E2>;
-    tapError: (f: (error: E) => void) => FPromise<T, E>;
-    recover: (fallback: T) => FPromise<T, never>;
-    recoverWith: (f: (error: E) => T) => FPromise<T, never>;
-    recoverWithF: <E2>(f: (error: E) => FPromise<T, E2>) => FPromise<T, E2>;
-    filterError: <E2 extends E>(predicate: (error: E) => boolean, handler: (error: E) => FPromise<T, E2>) => FPromise<T, E>;
-    logError: (logger: (error: E, context: ErrorContext) => void) => FPromise<T, E>;
-    toPromise: () => Promise<T>;
-    toEither: () => Promise<T>;
-    map: <U extends Type>(f: (value: T) => U) => FPromise<U, E>;
-    flatMap: <U extends Type>(f: (value: T) => FPromise<U, E> | PromiseLike<U>) => FPromise<U, E>;
-    flatMapAsync: <U extends Type>(f: (value: T) => PromiseLike<U>) => Promise<U>;
-}
-/**
- * Creates an FPromise from an executor function.
- *
- * @template T - The type of the value that the FPromise resolves to
- * @template E - The type of the error that the FPromise may reject with
- * @param executor - A function that receives resolve and reject functions
- * @returns An FPromise instance
- */
-declare const FPromise: (<T extends Type, E = unknown>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: E) => void) => void) => FPromise<T, E>) & {
-    /**
-     * Creates an FPromise that resolves to the provided value.
-     *
-     * @template T - The type of the value
-     * @template E - The type of the error (defaults to never since this FPromise won't reject)
-     * @param value - The value to resolve with
-     * @returns An FPromise that resolves to the value
-     *
-     * @example
-     * const promise = FPromise.resolve(42)
-     * // promise resolves to 42
-     */
-    resolve: <T, E = never>(value: T | PromiseLike<T>) => FPromise<T, E>;
-    /**
-     * Creates an FPromise that rejects with the provided reason.
-     *
-     * @template T - The type of the value (which will never be produced)
-     * @template E - The type of the error
-     * @param reason - The reason for rejection
-     * @returns An FPromise that rejects with the reason
-     *
-     * @example
-     * const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
-     * // promise rejects with Error("Something went wrong")
-     */
-    reject: <T, E = unknown>(reason: E) => FPromise<T, E>;
-    /**
-     * Creates an FPromise from a regular Promise.
-     *
-     * @template T - The type of the value
-     * @template E - The type of the error
-     * @param promise - The Promise to convert
-     * @returns An FPromise that resolves or rejects with the same value or error
-     *
-     * @example
-     * const promise = FPromise.from(fetch("https://api.example.com/data"))
-     * // promise is an FPromise that resolves or rejects based on the fetch result
-     */
-    from: <T, E = unknown>(promise: Promise<T>) => FPromise<T, E>;
-    /**
-     * Creates an FPromise from an Either.
-     * If the Either is a Right, the FPromise resolves with the Right value.
-     * If the Either is a Left, the FPromise rejects with the Left value.
-     *
-     * @template L - The type of the Left value (error)
-     * @template R - The type of the Right value (success)
-     * @param either - The Either to convert
-     * @returns An FPromise that resolves or rejects based on the Either
-     *
-     * @example
-     * const either = Right<Error, number>(42)
-     * const promise = FPromise.fromEither(either)
-     * // promise resolves to 42
-     */
-    fromEither: <L, R>(either: Either<L, R>) => FPromise<R, L>;
-    /**
-     * Runs multiple FPromises in parallel and returns an array of results.
-     * Similar to Promise.all, this will reject if any of the promises reject.
-     *
-     * @template T - The type of the values
-     * @template E - The type of the error
-     * @param promises - An array of FPromises, Promises, or values
-     * @returns An FPromise that resolves to an array of results
-     *
-     * @example
-     * const promises = [FPromise.resolve(1), FPromise.resolve(2), 3]
-     * const result = await FPromise.all(promises).toPromise()
-     * // result is [1, 2, 3]
-     */
-    all: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T> | T>) => FPromise<T[], E>;
-    /**
-     * Like Promise.allSettled, returns results of all promises whether they succeed or fail.
-     * This will always resolve, never reject.
-     *
-     * @template T - The type of the values
-     * @template E - The type of the errors
-     * @param promises - An array of FPromises or Promises
-     * @returns An FPromise that resolves to an array of Either results
-     *
-     * @example
-     * const promises = [FPromise.resolve(1), FPromise.reject<number, Error>(new Error("Failed"))]
-     * const result = await FPromise.allSettled(promises).toPromise()
-     * // result is [Right(1), Left(Error("Failed"))]
-     */
-    allSettled: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<Array<Either<E, T>>, never>;
-    /**
-     * Like Promise.race, returns the first promise to settle (either resolve or reject).
-     *
-     * @template T - The type of the values
-     * @template E - The type of the errors
-     * @param promises - An array of FPromises or Promises
-     * @returns An FPromise that resolves or rejects with the result of the first promise to settle
-     *
-     * @example
-     * const slow = FPromise.resolve(1).tap(() => new Promise(r => setTimeout(r, 100)))
-     * const fast = FPromise.resolve(2).tap(() => new Promise(r => setTimeout(r, 50)))
-     * const result = await FPromise.race([slow, fast]).toPromise()
-     * // result is 2
-     */
-    race: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
-    /**
-     * Like Promise.any, returns the first promise to fulfill.
-     * This will only reject if all promises reject.
-     *
-     * @template T - The type of the values
-     * @template E - The type of the errors
-     * @param promises - An array of FPromises or Promises
-     * @returns An FPromise that resolves with the first promise to fulfill or rejects if all promises reject
-     *
-     * @example
-     * const promises = [
-     *   FPromise.reject<number, Error>(new Error("First failed")),
-     *   FPromise.resolve(2),
-     *   FPromise.reject<number, Error>(new Error("Third failed"))
-     * ]
-     * const result = await FPromise.any(promises).toPromise()
-     * // result is 2
-     */
-    any: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
-    /**
-     * Retries an operation with exponential backoff.
-     * This is useful for operations that may fail temporarily, such as network requests.
-     *
-     * @template T - The type of the value
-     * @template E - The type of the error
-     * @param operation - A function that returns an FPromise
-     * @param options - Configuration options for the retry
-     * @param options.maxRetries - Maximum number of retry attempts
-     * @param options.baseDelay - Base delay in milliseconds (default: 100)
-     * @param options.shouldRetry - Function that determines whether to retry based on the error (default: always retry)
-     * @returns An FPromise that resolves when the operation succeeds or rejects after all retries fail
-     *
-     * @example
-     * const operation = () => {
-     *   if (Math.random() > 0.8) {
-     *     return FPromise.resolve("Success!")
-     *   }
-     *   return FPromise.reject<string, Error>(new Error("Temporary failure"))
-     * }
-     *
-     * const result = await FPromise.retryWithBackoff(operation, {
-     *   maxRetries: 3,
-     *   baseDelay: 100,
-     *   shouldRetry: (error) => error.message === "Temporary failure"
-     * }).toPromise()
-     */
-    retryWithBackoff: <T, E = unknown>(operation: () => FPromise<T, E>, options: {
-        maxRetries: number;
-        baseDelay?: number;
-        shouldRetry?: (error: E, attempt: number) => boolean;
-    }) => FPromise<T, E>;
-};
-
-type TaskParams = {
-    name?: string;
-    description?: string;
-};
-type TaskInfo = {
-    _task: TaskParams;
-};
-type TaskException<T> = Either<Throwable, T> & TaskInfo;
-/**
- * TaskException factory function
- * @param error
- * @param _task
- * @param data
- * @constructor
- */
-declare const TaskException: <T>(error: unknown, data?: unknown, _task?: TaskParams) => TaskException<T>;
-type TaskResult<T> = Either<Throwable, T> & TaskInfo;
-declare const TaskResult: <T>(data: T, _task?: TaskParams) => TaskResult<T>;
-type Sync<T> = Either<Throwable, T>;
-type Async<T> = FPromise<Sync<T>>;
-/**
- * Task adapter for bridging promise-based code with functional error handling patterns
- */
-declare const Task: <T = unknown>(params?: TaskParams) => {
-    _type: string;
-    /**
-     * Run an async operation with explicit try/catch/finally semantics
-     * Returns a raw Promise that can interact with traditional Promise-based code
-     */
-    Async: <U = T>(t: () => U | Promise<U>, e?: (error: unknown) => unknown, f?: () => Promise<void> | void) => FPromise<U>;
-    /**
-     * Run a synchronous operation with explicit try/catch/finally semantics
-     * Returns an Either for functional error handling
-     */
-    Sync: <U = T>(t: () => U, e?: (error: unknown) => unknown, f?: () => void) => Sync<U>;
-    /**
-     * Create a successful Task result
-     */
-    success: (data: T) => TaskResult<T>;
-    /**
-     * Create a failed Task result
-     */
-    fail: (error: unknown) => TaskException<T>;
-    /**
-     * Convert a Promise-returning function to a Task-compatible function
-     */
-    fromPromise: <U, Args extends unknown[]>(promiseFn: (...args: Args) => Promise<U>) => ((...args: Args) => FPromise<U>);
-    /**
-     * Convert a Task result to a Promise
-     */
-    toPromise: <U>(taskResult: TaskResult<U> | TaskException<U>) => Promise<U>;
-    toString(): string;
-    _tag: string;
-};
-
-type TypeNames = "Success" | "Failure";
-type Try<T> = {
-    readonly _tag: TypeNames;
-    readonly error: Error | undefined;
-    isSuccess: () => boolean;
-    isFailure: () => boolean;
-    get: () => T;
-    getOrElse: (defaultValue: T) => T;
-    orElse: (alternative: Try<T>) => Try<T>;
-    orThrow: (error: Error) => T;
-    toEither: () => Either<Error, T>;
-    map: <U>(f: (value: T) => U) => Try<U>;
-    flatMap: <U>(f: (value: T) => Try<U>) => Try<U>;
-    toString: () => string;
-} & Typeable<TypeNames> & Valuable<TypeNames, T | Error>;
-declare const Try: <T>(f: () => T) => Try<T>;
-
-/**
- * Type function for representing higher-kinded types
- */
-type Kind<F, A> = F extends (arg: infer T) => infer R ? R : never;
-/**
- * Type constructors for common Functype data types
- */
-type OptionKind = <A>(a: A) => Option<A>;
-type ListKind = <A>(a: A) => List<A>;
-type EitherKind<E> = <A>(a: A) => Either<E, A>;
-type TryKind = <A>(a: A) => Try<A>;
-/**
- * Universal type that includes all potential return types from the HKT functions
- * Used to avoid 'any' usage which the linter prohibits
- */
-type UniversalContainer = Option<unknown> | List<unknown> | Either<unknown, unknown> | Try<unknown>;
-/**
- * HKT provides utilities for working with higher-kinded types
- * This allows writing generic code that works across different
- * container types like Option, List, Either, etc.
- */
-declare const HKT: {
-    (): {
-        _type: string;
-        map: <F, A, B>(fa: unknown, f: (a: A) => B) => unknown;
-        flatten: <F, A>(ffa: unknown) => unknown;
-        flatMap: <F, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
-        ap: <F, A, B>(ff: unknown, fa: unknown) => unknown;
-        sequence: <F, G, A>(fga: unknown) => unknown;
-        traverse: <F, G, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
-        toString(): string;
-        _tag: string;
-    };
-    map<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => B): unknown;
-    flatten<F = unknown, A = unknown>(ffa: unknown): unknown;
-    flatMap<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
-    ap<F = unknown, A = unknown, B = unknown>(ff: unknown, fa: unknown): unknown;
-    sequence<F = unknown, G = unknown, A = unknown>(fga: unknown): unknown;
-    traverse<F = unknown, G = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
-    isOption: <T extends Type>(value: unknown) => value is Option<T>;
-    isList: <T extends Type>(value: unknown) => value is List<T>;
-    isEither: <E extends Type, A extends Type>(value: unknown) => value is Either<E, A>;
-    isTry: <T extends Type>(value: unknown) => value is Try<T>;
-};
-
-type Identity<T> = {
-    id: T;
-    isSame?: (other: Identity<T>) => boolean;
-};
-declare function Identity<T>(value: T): Identity<T>;
-
-type IESMap<K, V> = Map<K, V>;
-
-type SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, "map" | "flatMap">;
-type Map$1<K, V> = {
-    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>;
-    flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => IterableType<[K2, V2]>): Map$1<K2, V2>;
-    get(key: K): Option<V>;
-    getOrElse(key: K, defaultValue: V): V;
-    orElse(key: K, alternative: Option<V>): Option<V>;
-} & SafeTraversable<K, V> & Collection<Tuple<[K, V]>> & Typeable<"Map"> & Valuable<"Map", IESMap<K, V>>;
-declare const Map$1: <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null) => Map$1<K, V>;
-
-type Traversable<A extends Type> = Functor<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;
-    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
-    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
-};
-
-export { type Async as A, Base as B, Companion as C, Either as E, FPromise as F, HKT as H, Identity as I, type Kind as K, List as L, Map$1 as M, None, type OptionKind as O, Option, Right as R, Set as S, Some, type TestEither as T, type UniversalContainer as U, Left as a, isLeft as b, TypeCheckRight as c, TypeCheckLeft as d, tryCatchAsync as e, type ErrorContext as f, FPromiseCompanion as g, Try as h, isRight as i, type Traversable as j, type TaskParams as k, type TaskInfo as l, TaskException as m, TaskResult as n, type Sync as o, Task as p, type ThrowableType as q, Throwable as r, type ListKind as s, tryCatch as t, type EitherKind as u, type TryKind as v, type IterableType as w };
+export * from './Option';