import { t as Brand } from "./Brand-bfnGXuum.js";
import { d as Type, l as Pipe, o as Serializable, r as Typeable, t as Tuple, u as Foldable } from "./Tuple-B8KM-H8Y.js";
//#region src/conditional/Cond.d.ts
/**
 * Conditional expression that enforces exhaustive returns without early returns.
 * Similar to Scala's if/else expressions that always return a value.
 *
 * @example
 * const discount = Cond.of<number>()
 *   .when(isPremiumMember, 0.2)
 *   .elseWhen(isRegularMember, 0.1)
 *   .else(0)
 *
 * @example
 * // Chaining multiple conditions
 * const status = Cond.of<string>()
 *   .when(response.status >= 500, "Server Error")
 *   .elseWhen(response.status >= 400, "Client Error")
 *   .elseWhen(response.status >= 200, "Success")
 *   .else("Unknown")
 */
type Cond<T extends Type> = {
  /**
   * Add an if condition
   */
  when: (condition: boolean, value: T | (() => T)) => Cond<T>;
  /**
   * Add an else-if condition
   */
  elseWhen: (condition: boolean, value: T | (() => T)) => Cond<T>;
  /**
   * Terminal else clause - required to get the result
   */
  else: (value: T | (() => T)) => T;
  /**
   * Get the result if a condition was met, throws if no condition met
   */
  orThrow: () => T;
};
/** @internal */
type LazyCondChain<T> = {
  when: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
  elseWhen: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
  else: (value: () => T) => T;
};
/**
 * Conditional expression builder for functional if/else chains
 * @example
 * // Basic usage
 * const size = Cond.of<string>()
 *   .when(value > 100, "large")
 *   .elseWhen(value > 50, "medium")
 *   .else("small")
 *
 * @example
 * // Pattern matching
 * const message = Cond.match(errorCode)({
 *   404: "Not Found",
 *   500: "Server Error",
 *   200: "OK"
 * })
 *
 * @example
 * // Lazy evaluation
 * const result = Cond.lazy<string>()
 *   .when(() => checkCondition1(), () => "Result 1")
 *   .when(() => checkCondition2(), () => "Result 2")
 *   .else(() => "Default")
 */
declare const Cond: (<T extends Type>() => Cond<T>) & {
  /**
   * Create a conditional expression that must end with else
   * @example
   * const x = 7
   * const result = Cond.of<string>()
   *   .when(x > 10, "large")
   *   .elseWhen(x > 5, "medium")
   *   .else("small")
   * // result = "medium"
   *
   * @example
   * // With lazy evaluation
   * const discount = Cond.of<number>()
   *   .when(isPremium, () => calculatePremiumDiscount())
   *   .when(isLoyal, () => calculateLoyaltyDiscount())
   *   .else(0)
   */
  of: <T extends Type>() => Cond<T>;
  /**
   * Pattern matching helper that ensures exhaustiveness
   * @example
   * type Status = "pending" | "success" | "error"
   * const status: Status = "success"
   * const result = Cond.match(status)({
   *   "pending": "Waiting...",
   *   "success": "Done!",
   *   "error": "Failed!"
   * })
   * // result = "Done!"
   *
   * @example
   * // With function values
   * const action = "compute"
   * const result = Cond.match(action)({
   *   "compute": () => expensiveComputation(),
   *   "cache": () => getCachedValue(),
   *   "skip": () => defaultValue
   * })
   */
  match: <T extends string | number | symbol>(value: T) => <R extends Type>(cases: Record<T, R | (() => R)>) => R;
  /**
   * Create a lazy conditional that defers evaluation
   * @example
   * // Only evaluates conditions and values when needed
   * const getMessage = Cond.lazy<string>()
   *   .when(() => isError(), () => computeErrorMessage())
   *   .when(() => isWarning(), () => computeWarningMessage())
   *   .else(() => "Success")
   *
   * @example
   * // Complex conditional with expensive checks
   * const result = Cond.lazy<Action>()
   *   .when(
   *     () => user.role === "admin" && checkAdminPermissions(),
   *     () => ({ type: "admin", permissions: loadAdminPermissions() })
   *   )
   *   .when(
   *     () => user.role === "user" && user.isActive,
   *     () => ({ type: "user", permissions: loadUserPermissions() })
   *   )
   *   .else(() => ({ type: "guest", permissions: [] }))
   */
  lazy: <T extends Type>() => LazyCondChain<T>;
};
//#endregion
//#region src/do/protocol.d.ts
/**
 * Protocol definitions for Do-notation
 * Separated from main Do module to avoid circular dependencies
 */
/**
 * Result type for Do-notation unwrapping
 * Indicates whether unwrapping succeeded and provides the value or error
 */
type DoResult<T> = {
  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<out T> {
  doUnwrap(): DoResult<T>;
}
//#endregion
//#region src/error/ParseError.d.ts
declare const ParseError: (message?: string) => Error & {
  name: "ParseError";
};
type ParseError = Error & {
  name: "ParseError";
};
//#endregion
//#region src/extractable/Extractable.d.ts
/**
 * Interface for operations that can fail with exceptions.
 * These methods should be used with care as they can throw at runtime.
 *
 * @interface Unsafe
 * @template T The type of value that can be extracted
 */
interface Unsafe<out 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.
 *
 * Covariance: T is declared `<out T>`. The fallback methods `orElse` and `or`
 * widen the result via `<T2>`, matching Scala's `getOrElse[B1 >: B](default: => B1): B1`
 * shape — when the caller passes a T-typed default the result is just T, and when
 * they pass a wider T2 the result union widens accordingly.
 *
 * Implementers that previously overrode `or`/`orElse` with widened signatures
 * (Option, Either, Try) can inherit from this base directly; their 0.58-era
 * `Omit<Extractable<T>, "or" | "orElse">` workarounds are no longer needed.
 */
interface Extractable<out T extends Type> extends Unsafe<T> {
  /**
   * Returns the contained value or a default value. The default may be of a
   * different type; the result widens to `T | T2`.
   * @param defaultValue - The value to return if extraction fails
   * @returns The contained value or defaultValue
   */
  orElse<T2 extends Type>(defaultValue: T2): T | T2;
  /**
   * Returns this container if it has a value, otherwise returns the alternative container.
   * The alternative may carry a different type; the result widens to `Extractable<T | T2>`.
   * @param alternative - The alternative container
   * @returns This container or the alternative
   */
  or<T2 extends Type>(alternative: Extractable<T2>): Extractable<T | T2>;
  /**
   * 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>;
//#endregion
//#region src/typeclass/ContainerOps.d.ts
/**
 * Universal operations that work on any container (single-value or collection).
 * These operations make sense for Option, Either, Try, List, Set, etc.
 *
 * @typeParam A - The type of value(s) in the container
 */
interface ContainerOps<out 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<out A extends Type, Self> {
  /**
   * Left-associative fold over all elements using an initial value and combining function.
   * Unlike foldLeft (which is curried), this provides a convenient uncurried signature.
   *
   * @example
   * ```typescript
   * List([1, 2, 3]).fold(0, (acc, x) => acc + x) // 6
   * ```
   *
   * @param initial - The initial accumulator value
   * @param fn - A function that combines the accumulator with each element
   * @returns The final accumulated value
   */
  fold<B>(initial: B, fn: (acc: B, a: A) => B): B;
  /**
   * 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>;
  /**
   * Takes the first n elements from the collection.
   */
  take(n: number): Self;
  /**
   * Takes elements from the start while the predicate is true.
   */
  takeWhile(p: (a: A) => boolean): Self;
  /**
   * Takes the last n elements from the collection.
   */
  takeRight(n: number): Self;
  /**
   * Gets the last element of the collection.
   */
  get last(): A | undefined;
  /**
   * Gets the last element wrapped in Option.
   */
  get lastOption(): Option<A>;
  /**
   * Gets all elements except the first.
   */
  get tail(): Self;
  /**
   * Gets all elements except the last.
   */
  get init(): Self;
  /**
   * Converts the collection to an array.
   */
  toArray<B = A>(): B[];
}
//#endregion
//#region src/typeclass/Functor.d.ts
/**
 * Functor type class - supports mapping over wrapped values
 *
 * Laws:
 * - Identity: fa.map(x => x) ≡ fa
 * - Composition: fa.map(f).map(g) ≡ fa.map(x => g(f(x)))
 */
interface Functor<out 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<out 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<out 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<out A extends Type> extends Monad<A> {
  flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<AsyncMonad<B>>): PromiseLike<AsyncMonad<B>>;
}
//#endregion
//#region src/typeclass/Promisable.d.ts
/**
 * Promisable trait - supports conversion to Promise
 *
 * Represents containers or values that can be converted to Promise form.
 * This enables integration with async/await patterns and Promise-based APIs
 * while maintaining functional programming principles.
 *
 * @template A - The type of value contained within the Promise
 *
 * @example
 * ```typescript
 * const either: Either<string, number> = Right(42)
 * const promise: Promise<number> = either.toPromise()
 * // Promise resolves with 42
 *
 * const leftEither: Either<string, number> = Left("error")
 * const failedPromise: Promise<number> = leftEither.toPromise()
 * // Promise rejects with "error"
 * ```
 */
interface Promisable<out A extends Type> {
  /**
   * Converts this container to a Promise
   *
   * The behavior depends on the implementing container:
   * - Success/Right/Some containers resolve with their value
   * - Failure/Left/None containers reject with their error/default error
   *
   * @returns A Promise that resolves or rejects based on the container's state
   */
  toPromise(): Promise<A>;
}
//#endregion
//#region src/typeclass/variance.d.ts
/**
 * Variance helpers — small utilities for expressing covariance-safe signatures
 * when TypeScript's type system doesn't offer the exact constraint we need.
 *
 * Motivation: Scala has lower-bound type parameters like `def reduce[B >: A](op: (B, B) => B): B`
 * — B must be a supertype of A. TypeScript lacks lower bounds, so a naive port
 * (`reduce<B = A>(op: (b: B, a: B) => B): B`) lets the caller pick ANY B, including
 * unrelated types. At runtime that's a footgun: `List<number>.reduce<string>(...)` would
 * compile but run as number addition typed as string.
 *
 * `Widen<A, B>` closes that gap using a conditional type. When B is truly a supertype
 * of A (including the default case B = A), `Widen<A, B>` is B. When B is unrelated,
 * it resolves to `never`, which makes the callback uncallable and produces a compile
 * error at the call site.
 *
 * @module typeclass/variance
 */
/**
 * The TypeScript equivalent of Scala's `B >: A` (B is a supertype of A).
 *
 * Resolves to `B` when `A extends B` (i.e., B is a legitimate supertype of A, or B = A).
 * Resolves to `never` otherwise, which renders any callback position using Widen
 * uncallable — the user gets a compile-time error rather than a runtime type lie.
 *
 * @example
 * ```ts
 * // Inside a container interface:
 * reduce<B = A>(op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>): Widen<A, B>
 *
 * // Callers:
 * list.reduce((a, b) => a + b)          // B defaults to A, Widen<A,A> = A, fine
 * list.reduce<A | "extra">(...)         // A extends A | "extra", Widen = B, fine
 * list.reduce<UnrelatedType>(...)       // A doesn't extend Unrelated, Widen = never, compile error
 * ```
 */
type Widen<A, B> = A extends B ? B : never;
/**
 * Runtime-safe `reduce` over an array whose element type `A` may be narrower than
 * the accumulator type `B`. Centralizes the single `as unknown as B` cast that's
 * otherwise spread across every container's implementation.
 *
 * Safety: the cast is sound because the `Widen<A, B>` type-level constraint at the
 * public API layer guarantees `A <: B`. When that holds, A values flowing into the
 * callback are valid B values at runtime — exactly what Scala's `[B >: A]` provides.
 *
 * @param arr - source array of A values
 * @param op - accumulator operation typed over B (where B is A or a supertype)
 * @returns the folded value, typed as B
 */
declare const reduceWiden: <A, B>(arr: readonly A[], op: (b: B, a: B) => B) => B;
/**
 * Right-associative variant of {@link reduceWiden}. Same safety argument.
 */
declare const reduceRightWiden: <A, B>(arr: readonly A[], op: (b: B, a: B) => B) => B;
//#endregion
//#region src/either/Either.d.ts
/**
 * Either type module
 * @module Either
 * @category Core
 */
/**
 * Shared interface for Either variants. Contains all methods and type guards but
 * does NOT include the discriminant `_tag` or `value` — those are declared on the
 * variant interfaces (LeftOf / RightOf) so that Either acts as a true discriminated
 * union. After `if (e.isLeft())`, the else branch narrows `e` to RightOf<L,R> and
 * `e.value` narrows to R without a cast.
 */
interface EitherBase<out L extends Type, out R extends Type> extends FunctypeSum<R, "Left" | "Right">, Promisable<R>, Doable<R>, Reshapeable<R>, Extractable<R> {
  isLeft(): this is LeftOf<L, R>;
  isRight(): this is RightOf<L, R>;
  orElse<R2 extends Type>(defaultValue: R2): R | R2;
  orThrow: (error?: Error) => R;
  /**
   * Returns the right value, or calls the never-returning handler with the Left's value.
   * Use this when you have a helper like `(msg) => fail(msg, 2)` that terminates the
   * program — the result type is unconditionally `R`, so you avoid the TypeScript
   * narrowing trap where `if (e.isLeft()) fail(...)` fails to narrow `e.value` when
   * `fail` is an arrow function typed as `(...): never`.
   */
  expect: (handler: (value: L) => never) => R;
  or<L2 extends Type, R2 extends Type>(alternative: Either<L2, R2>): Either<L | L2, R | R2>;
  orNull: () => R | null;
  orUndefined: () => R | undefined;
  readonly map: <U extends Type>(f: (value: R) => U) => Either<L, U>;
  ap: <L2 extends Type, U extends Type>(ff: Either<L2, (value: R) => U>) => Either<L | L2, 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: <L2 extends Type, U extends Type>(f: (value: R) => Either<L2, U>) => Either<L | L2, U>;
  flatMapAsync: <L2 extends Type, U extends Type>(f: (value: R) => Promise<Either<L2, U>>) => Promise<Either<L | L2, U>>;
  toOption: () => Option<R>;
  toString: () => string;
  [Symbol.iterator]: () => Iterator<R>;
  yield: () => Generator<R, void, unknown>;
  traverse: <L2 extends Type, U extends Type>(f: (value: R) => Either<L2, U>) => Either<L | L2, U[]>;
  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>;
  /**
   * Applies a predicate to the Right value. If the predicate fails, short-circuits
   * to a Left carrying the value produced by `onUnsatisfied`. Left passes through
   * unchanged (predicate not evaluated). Lets you turn a value-level guard into the
   * Left channel without breaking the chain with an `if/return Left(...)` ladder.
   * @param predicate - The predicate to test the Right value
   * @param onUnsatisfied - Builds the new Left value when the predicate fails
   * @returns Right if the predicate holds, Left(onUnsatisfied(value)) otherwise
   */
  filterOrElse: <L2 extends Type>(predicate: (value: R) => boolean, onUnsatisfied: (value: R) => L2) => Either<L | 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;
  /**
   * Async variant of fold. Accepts sync or async handlers on either branch and
   * always returns a Promise, keeping chains fluent when at least one branch is async.
   */
  foldAsync: <T extends Type>(onLeft: (value: L) => T | Promise<T>, onRight: (value: R) => T | Promise<T>) => Promise<T>;
  swap: () => Either<R, L>;
  /**
   * Pipes the value through the provided function based on whether this is a Left or Right
   */
  pipeEither<U extends Type>(onLeft: (value: L) => U, onRight: (value: R) => U): U;
  /**
   * Pipes the Either value through the provided function
   */
  pipe<U extends Type>(f: (value: L | R) => U): U;
  /**
   * Pattern matches over the Either, applying a handler function based on the variant
   */
  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.
   * Emits the canonical functype envelope with `@functype: "Either"` so
   * native `JSON.stringify` recursion (e.g. inside a plain object body)
   * produces a marker-bearing envelope that survives a round-trip through
   * `Serialization.deserialize`.
   */
  toJSON(): {
    "@functype": "Either";
    _tag: "Left" | "Right";
    value: L | R;
  };
}
/**
 * Left variant of Either. Discriminated by `_tag: "Left"` with `value: L`.
 */
interface LeftOf<out L extends Type, out R extends Type> extends EitherBase<L, R> {
  readonly _tag: "Left";
  readonly value: L;
}
/**
 * Right variant of Either. Discriminated by `_tag: "Right"` with `value: R`.
 */
interface RightOf<out L extends Type, out R extends Type> extends EitherBase<L, R> {
  readonly _tag: "Right";
  readonly value: R;
}
/**
 * Either is a discriminated union of LeftOf and RightOf. TypeScript narrows
 * across both branches of `isLeft()` / `isRight()` and `_tag` checks. Variance
 * is inherited from LeftOf/RightOf (both covariant in L and R) — union type
 * aliases cannot carry their own variance annotations in TS.
 */
type Either<L extends Type, R extends Type> = LeftOf<L, R> | RightOf<L, R>;
type TestEither<L extends Type, R extends Type> = Either<L, R> & AsyncMonad<R>;
declare const Right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
declare const Left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
declare const isRight: <L extends Type, R extends Type>(either: Either<L, R>) => either is RightOf<L, R>;
declare const isLeft: <L extends Type, R extends Type>(either: Either<L, R>) => either is LeftOf<L, R>;
declare const tryCatch: <L extends Type, R extends Type>(f: () => R, onError: (error: unknown) => L) => Either<L, R>;
declare const TypeCheckRight: <L extends Type, R extends Type>(value: R) => TestEither<L, R>;
declare const TypeCheckLeft: <L extends Type, R extends Type>(value: L) => TestEither<L, R>;
declare const tryCatchAsync: <L extends Type, R extends Type>(f: () => Promise<R>, onError: (error: unknown) => L) => Promise<Either<L, R>>;
declare const Either: (<L extends Type, R extends Type>(value: R | L, isRight: boolean) => Either<L, R>) & {
  /**
   * Creates a Left instance
   * @param value - The left value
   * @returns Left Either
   */
  left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
  /**
   * Creates a Right instance
   * @param value - The right value
   * @returns Right Either
   */
  right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
  /**
   * Creates a Right<L, void> — convenience for "operation succeeded with no meaningful value".
   * Avoids variance quirks around Either<L, void> vs Either<L, undefined>.
   * @returns Right Either with void value
   */
  void: <L extends Type>() => Either<L, void>;
  /**
   * 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 RightOf<L, 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 LeftOf<L, R>;
  /**
   * Combines an array of Eithers into a single Either containing an array
   * @param eithers - Array of Either values
   * @returns Either with array of values or first Left encountered
   */
  sequence: <L extends Type, R extends Type>(eithers: Either<L, R>[]) => Either<L, R[]>;
  /**
   * Maps an array through a function that returns Either, then sequences the results
   * @param arr - Array of values
   * @param f - Function that returns Either
   * @returns Either with array of results or first Left encountered
   */
  traverse: <L extends Type, R extends Type, U extends Type>(arr: R[], f: (value: R) => Either<L, U>) => Either<L, U[]>;
  /**
   * Creates an Either from a nullable value
   * @param value - The value that might be null or undefined
   * @param leftValue - The value to use for Left if value is null/undefined
   * @returns Right if value is not null/undefined, Left otherwise
   */
  fromNullable: <L extends Type, R extends Type>(value: R | null | undefined, leftValue: L) => Either<L, R>;
  /**
   * Creates an Either based on a predicate
   * @param value - The value to test
   * @param predicate - The predicate function
   * @param leftValue - The value to use for Left if predicate fails
   * @returns Right if predicate passes, Left otherwise
   */
  fromPredicate: <L extends Type, R extends Type>(value: R, predicate: (value: R) => boolean, leftValue: L) => Either<L, R>;
  /**
   * Applicative apply - applies a wrapped function to a wrapped value
   * @param eitherF - Either containing a function
   * @param eitherV - Either containing a value
   * @returns Either with function applied to value
   */
  ap: <L extends Type, R extends Type, U extends Type>(eitherF: Either<L, (value: R) => U>, eitherV: Either<L, R>) => Either<L, U>;
  /**
   * Creates an Either from a Promise
   * @param promise - The Promise to convert
   * @param onRejected - Function to convert rejection reason to Left value
   * @returns Promise that resolves to Either
   */
  fromPromise: <L, R>(promise: Promise<R>, onRejected: (reason: unknown) => L) => Promise<Either<L, R>>;
  /**
   * Creates an Either from JSON string
   * @param json - The JSON string
   * @returns Either instance
   */
  fromJSON: <L extends Type, R extends Type>(json: string) => Either<L, R>;
  /**
   * Creates an Either from YAML string
   * @param yaml - The YAML string
   * @returns Either instance
   */
  fromYAML: <L extends Type, R extends Type>(yaml: string) => Either<L, R>;
  /**
   * Creates an Either from binary string
   * @param binary - The binary string
   * @returns Either instance
   */
  fromBinary: <L extends Type, R extends Type>(binary: string) => Either<L, R>;
};
//#endregion
//#region src/list/LazyList.d.ts
/**
 * LazyList provides lazy evaluation for list operations.
 * Operations are deferred until the list is materialized.
 *
 * @example
 * // Basic lazy evaluation
 * const result = LazyList([1, 2, 3, 4, 5])
 *   .map(x => x * 2)
 *   .filter(x => x > 5)
 *   .toArray() // [6, 8, 10]
 *
 * @example
 * // Infinite sequences with take
 * const fibonacci = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
 *   .map(([a]) => a)
 *   .take(10)
 *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
 */
interface LazyList<out A extends Type> extends Foldable<A>, Pipe<LazyList<A>>, Serializable<LazyList<A>>, Typeable<"LazyList"> {
  readonly [Symbol.toStringTag]: string;
  [Symbol.iterator](): Iterator<A>;
  map<B extends Type>(f: (a: A) => B): LazyList<B>;
  flatMap<B extends Type>(f: (a: A) => LazyList<B>): LazyList<B>;
  filter(predicate: (a: A) => boolean): LazyList<A>;
  take(n: number): LazyList<A>;
  drop(n: number): LazyList<A>;
  takeWhile(predicate: (a: A) => boolean): LazyList<A>;
  dropWhile(predicate: (a: A) => boolean): LazyList<A>;
  /** Concatenate with another lazy list, possibly widening (Scala: `++[B >: A]`). */
  concat<B extends Type>(other: LazyList<B>): LazyList<A | B>;
  zip<B extends Type>(other: LazyList<B>): LazyList<[A, B]>;
  takeRight(n: number): LazyList<A>;
  reverse(): LazyList<A>;
  distinct(): LazyList<A>;
  zipWithIndex(): LazyList<[A, number]>;
  get head(): A | undefined;
  get headOption(): Option<A>;
  get last(): A | undefined;
  get lastOption(): Option<A>;
  get tail(): LazyList<A>;
  get init(): LazyList<A>;
  fold<B>(initial: B, fn: (acc: B, a: A) => B): B;
  toList(): List<A>;
  toArray(): A[];
  forEach(f: (a: A) => void): void;
  reduce<B extends Type>(f: (acc: B, a: A) => B, initial: B): B;
  find(predicate: (a: A) => boolean): Option<A>;
  some(predicate: (a: A) => boolean): boolean;
  every(predicate: (a: A) => boolean): boolean;
  count(): number;
  toString(): string;
}
/**
 * Lazy list implementation for efficient deferred computation
 * @example
 * // Process large datasets efficiently
 * const result = LazyList.range(1, 1000000)
 *   .filter(x => x % 2 === 0)
 *   .map(x => x * x)
 *   .take(5)
 *   .toArray() // [4, 16, 36, 64, 100]
 *
 * @example
 * // Infinite sequences
 * const primes = LazyList.iterate(2, n => n + 1)
 *   .filter(isPrime)
 *   .take(10)
 *   .toArray() // First 10 prime numbers
 *
 * @example
 * // Combining operations
 * const evens = LazyList.range(0, 100, 2)
 * const odds = LazyList.range(1, 100, 2)
 * const combined = evens.zip(odds)
 *   .map(([e, o]) => e + o)
 *   .take(5)
 *   .toArray() // [1, 5, 9, 13, 17]
 */
declare const LazyList: (<A extends Type>(iterable: Iterable<A>) => LazyList<A>) & {
  /**
   * Create an empty LazyList
   * @example
   * const empty = LazyList.empty<number>()
   * empty.toArray() // []
   */
  empty: <A extends Type>() => LazyList<A>;
  /**
   * Create a LazyList from a single value
   * @example
   * const single = LazyList.of(42)
   *   .map(x => x * 2)
   *   .toArray() // [84]
   */
  of: <A extends Type>(value: A) => LazyList<A>;
  /**
   * Create a LazyList from multiple values
   */
  from: <A extends Type>(...values: A[]) => LazyList<A>;
  /**
   * Reconstruct a LazyList from a JSON envelope emitted by `serialize().toJSON()`
   * or instance `toJSON()`. Verifies `@functype === "LazyList"` when the marker
   * is present (canonical from 1.2.0). The materialized array becomes the new
   * LazyList's backing — laziness can't survive JSON serialization.
   */
  fromJSON: <A extends Type>(json: string) => LazyList<A>;
  /**
   * Create an infinite LazyList by repeatedly applying a function
   * @example
   * // Powers of 2
   * const powers = LazyList.iterate(1, x => x * 2)
   *   .take(10)
   *   .toArray() // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
   *
   * @example
   * // Fibonacci sequence
   * const fib = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
   *   .map(([a]) => a)
   *   .take(8)
   *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13]
   */
  iterate: <A extends Type>(initial: A, f: (a: A) => A) => LazyList<A>;
  /**
   * Create an infinite LazyList by repeatedly calling a function
   */
  generate: <A extends Type>(f: () => A) => LazyList<A>;
  /**
   * Create a LazyList of numbers from start to end (exclusive)
   * @example
   * LazyList.range(1, 6).toArray() // [1, 2, 3, 4, 5]
   * LazyList.range(0, 10, 2).toArray() // [0, 2, 4, 6, 8]
   * LazyList.range(10, 0, -1).toArray() // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
   *
   * @example
   * // Sum of squares from 1 to 100
   * const sum = LazyList.range(1, 101)
   *   .map(x => x * x)
   *   .reduce((a, b) => a + b, 0) // 338350
   */
  range: (start: number, end: number, step?: number) => LazyList<number>;
  /**
   * Create a LazyList that repeats a value n times (or infinitely if n is not provided)
   */
  repeat: <A extends Type>(value: A, n?: number) => LazyList<A>;
  /**
   * Create a LazyList that cycles through an iterable infinitely
   */
  cycle: <A extends Type>(iterable: Iterable<A>) => LazyList<A>;
};
//#endregion
//#region src/serialization/error-envelope.d.ts
/**
 * Canonical projection of `Error` to JSON, shared by every Serializable type
 * that carries an `Error` in its failure branch (`Try.Failure`, `Task.Err`,
 * `Lazy` with a thrown thunk).
 *
 * Round-trip guarantees:
 *  - `err.name` survives (preserves discriminator: `e.name === "TypeError"` works)
 *  - `err.message` survives
 *  - `err.stack` survives if present at serialize time
 *  - `err.cause` survives recursively (arbitrary nesting depth)
 *
 * What does NOT survive:
 *  - `instanceof TypeError` and other subclass identity checks (JSON cannot
 *    reconstruct user-defined classes without arbitrary code execution).
 *  - Custom Error-subclass fields (e.g. `HttpError.status`). The generic
 *    projection doesn't know about them; a future registry mechanism may
 *    address this.
 *
 * Use `e.name` for discriminator checks across the serialization boundary,
 * not `e instanceof SomeError`.
 */
type SerializedError = {
  readonly name: string;
  readonly message: string;
  readonly stack?: string;
  readonly cause?: SerializedError | string;
};
/**
 * Project an arbitrary thrown value to the canonical SerializedError shape.
 * Accepts both `Error` instances and non-Error throwables (strings, plain
 * objects, etc.). Non-Error throwables get `name: "NonErrorThrowable"` and
 * the best textual representation we can produce.
 */
declare const serializeError: (err: unknown) => SerializedError;
/**
 * Reconstruct an Error from a SerializedError. The reconstructed Error has
 * the same `name`, `message`, `stack`, and `cause` chain as the original,
 * but its prototype is always `Error.prototype` — subclass identity does
 * not round-trip.
 *
 * A `string` is accepted as a shorthand for `{name: "Error", message: <string>}`,
 * matching what `serializeCause` emits when a `cause` was a bare string.
 */
declare const deserializeError: (s: SerializedError | string) => Error;
//#endregion
//#region src/serialization/SerializationCompanion.d.ts
/**
 * Serialization result containing methods for different formats
 */
interface SerializationResult {
  /** Serializes to JSON string */
  toJSON: () => string;
  /** Serializes to YAML string */
  toYAML: () => string;
  /** Serializes to base64-encoded binary string */
  toBinary: () => string;
}
/**
 * The namespaced marker stamped on every functype envelope. Defends against
 * `_tag` collisions with Effect/fp-ts (which use identical strings like
 * `"Some"`, `"Left"`, `"Success"`). A value WITHOUT this marker is treated
 * as "not ours" by `Serialization.deserialize`.
 *
 * See `docs/archive/proposals/universal-deserialize-changes.md` Change 0 for the
 * full rationale.
 */
declare const FUNCTYPE_MARKER: "@functype";
/**
 * Shape of every functype JSON envelope. The marker identifies the type,
 * `_tag` (when present) discriminates variants within that type, and the
 * remaining payload fields are type-specific (`value` for canonical cases,
 * `error` for failure branches, etc.).
 */
type FunctypeEnvelope = {
  readonly [FUNCTYPE_MARKER]: string;
  readonly _tag?: string;
  readonly [key: string]: unknown;
};
/**
 * Build the canonical `{@functype, _tag, value}` envelope OBJECT used by both
 * the instance `toJSON()` (which returns it directly so native JSON.stringify
 * can recurse) and the `serialize().toJSON()` method (which stringifies it).
 *
 * `_tag` is always emitted — variant-less types pass the same string for
 * marker and tag (default behavior when tag is omitted). Keeping `_tag`
 * across the board preserves back-compat for readers that did
 * `if (parsed._tag === "List")` against 1.1.0 envelopes.
 *
 * @param marker - The `@functype` type marker, e.g. `"Either"`, `"Option"`.
 * @param tag - The variant discriminator, e.g. `"Right"`, `"Some"`. Defaults
 *              to `marker` for types without variants (List, Map, etc.).
 * @param value - The payload.
 */
declare const envelope: (marker: string, tag: string | undefined, value: unknown) => FunctypeEnvelope;
/**
 * Build a non-canonical envelope where the payload doesn't fit the standard
 * `{value}` shape — e.g. `Try.Failure` carries `{error: SerializedError}`,
 * `Lazy`-with-thrown-thunk carries the same.
 *
 * @param marker - The `@functype` type marker.
 * @param tag - The variant discriminator (may be the same as marker for
 *              variant-less types).
 * @param fields - Additional payload fields merged into the envelope.
 */
declare const taggedEnvelope: (marker: string, tag: string, fields: Record<string, unknown>) => FunctypeEnvelope;
/**
 * Creates a serializer for the canonical envelope shape, with the `@functype`
 * marker stamped at the top level (Change 0 of the 1.2.0 universal-deserialize
 * work). Two forms:
 *
 *   createSerializer(marker, value)          // variant-less types (List, Map, …)
 *   createSerializer(marker, tag, value)     // variants (Either, Option, …)
 *
 * Variant-less envelopes are `{"@functype": marker, value}`. Variant envelopes
 * are `{"@functype": marker, _tag: tag, value}`.
 */
declare function createSerializer(marker: string, value: unknown): SerializationResult;
declare function createSerializer(marker: string, tag: string, value: unknown): SerializationResult;
/**
 * Creates a serializer for non-canonical envelopes whose payload doesn't
 * fit the `{value}` shape — e.g. failure branches that carry a structured
 * `SerializedError`. The envelope still carries the `@functype` marker
 * and `_tag` discriminator.
 *
 * @param marker - The `@functype` type marker.
 * @param tag - The variant discriminator.
 * @param fields - The payload fields (merged after marker + tag).
 */
declare const createTaggedSerializer: (marker: string, tag: string, fields: Record<string, unknown>) => SerializationResult;
/**
 * @deprecated Use `createTaggedSerializer` instead. Retained for backwards
 *             compatibility with any external callers; will be removed in a
 *             future major. The single internal caller (`Try.Failure`) has
 *             been migrated to `createTaggedSerializer`.
 *
 * Creates a serializer for complex objects with custom serialization logic.
 * Note: this variant does NOT stamp the `@functype` marker — callers must
 * include it in `data` themselves if they want envelope dispatch to work.
 */
declare const createCustomSerializer: (data: Record<string, unknown>) => SerializationResult;
/**
 * Generic deserializer from JSON. The `reconstructor` receives the full
 * parsed envelope including any `@functype` marker; per-type companions
 * verify the marker matches their expected value.
 */
declare const fromJSON: <T>(json: string, reconstructor: (parsed: {
  _tag?: string;
  [key: string]: unknown;
}) => T) => T;
/**
 * Generic deserializer from YAML (simple format)
 * @param yaml - The YAML string to parse
 * @param reconstructor - Function to reconstruct the type from parsed data
 * @returns Reconstructed instance
 */
declare const fromYAML: <T>(yaml: string, reconstructor: (parsed: {
  _tag?: string;
  [key: string]: unknown;
}) => T) => T;
/**
 * Generic deserializer from binary (base64-encoded JSON)
 * @param binary - The base64-encoded binary string
 * @param reconstructor - Function to reconstruct the type from parsed data
 * @returns Reconstructed instance
 */
declare const fromBinary: <T>(binary: string, reconstructor: (parsed: {
  _tag?: string;
  [key: string]: unknown;
}) => T) => T;
/**
 * Creates companion serialization methods for a type
 * @param reconstructor - Function to reconstruct the type from parsed data
 * @returns Companion methods object with fromJSON, fromYAML, and fromBinary
 */
declare const createSerializationCompanion: <T>(reconstructor: (parsed: {
  _tag?: string;
  [key: string]: unknown;
}) => T) => {
  fromJSON: (json: string) => T;
  fromYAML: (yaml: string) => T;
  fromBinary: (binary: string) => T;
};
declare namespace Serialization_d_exports {
  export { JSONValue, deserialize, deserializeStrict, fromEnvelope, isFunctypeValue, serialize, toEnvelope };
}
/**
 * The canonical JSON value type — anything `JSON.parse` can return and
 * anything `JSON.stringify` can accept as input. Used by `toEnvelope` /
 * `fromEnvelope` to express the contract precisely: the envelope is a
 * structured JSON shape, not opaque `unknown`. Lets consumers wiring this
 * API into another structured serializer (SuperJSON, DBOS custom
 * transformers) slot it in without a cast at the boundary.
 *
 * Added in 1.2.2 — `toEnvelope`/`fromEnvelope` previously typed input/output
 * as `unknown`, which forced a cast at the consumer side.
 */
type JSONValue = string | number | boolean | null | JSONValue[] | {
  [key: string]: JSONValue;
};
/**
 * Reconstruct any value from a JSON string. Lenient codec: walks the parsed
 * structure and rebuilds any value carrying an `@functype` marker via the
 * dispatch table; plain JSON without the marker walks through unchanged.
 * Returns `Try` so malformed JSON or unknown markers are expressible values
 * rather than thrown — matches the functype convention for expected-failure
 * paths.
 *
 * **Pass-through policy:** valid JSON without an `@functype` marker is
 * returned verbatim as `Success(value)`; only marker-carrying values are
 * reconstructed. Only malformed JSON (or an unknown marker) yields `Failure`.
 * For a strict variant that rejects unmarked input, see `deserializeStrict`.
 *
 * @example
 *   const result = Serialization.deserialize('{"@functype":"Either","_tag":"Right","value":5}')
 *   result.fold(e => console.error(e), v => console.log(v))  // → Right(5)
 *
 *   // Plain (non-functype) values pass through:
 *   Serialization.deserialize('{"name":"alice","age":30}')  // → Success({name, age})
 *
 *   // Embedding in another structured serializer (SuperJSON, DBOS)? See
 *   // `fromEnvelope` — taking a string here forces the consumer through a
 *   // JSON.stringify shim and SuperJSON re-walks strings character-by-character.
 */
declare const deserialize: (json: string) => Try<unknown>;
/**
 * Strict variant of `deserialize`: returns `Failure` when the parsed JSON
 * doesn't carry an `@functype` marker at the top level. Use this at API,
 * queue, or RPC boundaries where the wire format MUST be a functype value
 * and pass-through silence would be a bug.
 *
 * Implementation note: only the top-level value is checked for the marker.
 * Nested values inside it follow the same lenient pass-through rules as
 * `deserialize` — a `Right` containing a plain object still reconstructs
 * fine, you just can't START with a plain object.
 *
 * @example
 *   Serialization.deserializeStrict('{"@functype":"Option","_tag":"Some","value":1}')  // → Success(Some(1))
 *   Serialization.deserializeStrict('{"_tag":"Some","value":1}')                       // → Failure
 *   Serialization.deserializeStrict('42')                                              // → Failure
 */
declare const deserializeStrict: (json: string) => Try<unknown>;
/**
 * Serialize any value to a JSON string. Lenient codec: thin convenience over
 * `JSON.stringify` — functype instances self-stringify via their instance
 * `toJSON()` method (which emits the `@functype`-marked envelope), and
 * non-functype values pass through as plain JSON. Nested functype values
 * embedded in plain objects/arrays serialize correctly via the standard
 * JSON.stringify protocol with no walker needed.
 *
 * `undefined` is converted to `null` (matching the convention DBOS and
 * SuperJSON use; `JSON.stringify(undefined)` returns the string `"undefined"`
 * which is not valid JSON).
 */
declare const serialize: (value: unknown) => string;
/**
 * Serialize a value to a parsed JSON envelope (object/array/primitive) rather
 * than a string. Use this when nesting functype values inside another
 * **structured** serializer (SuperJSON / DBOS custom transformers / similar)
 * whose custom-transformer hook expects JSON values, not strings — passing a
 * string to such a hook causes the host to re-walk it character-by-character,
 * destroying the round-trip.
 *
 * Equivalent to `JSON.parse(serialize(value))` but exposed as a named entry
 * point so consumers don't carry the parse/stringify shim.
 *
 * Returns `JSONValue` (tightened from `unknown` in 1.2.2) so consumers can
 * drop the result straight into a host serializer's `serialize` hook without
 * a boundary cast.
 *
 * @example
 *   // Inside a DBOS custom serialization recipe — zero casts:
 *   DBOS.registerSerialization({
 *     name: "functype",
 *     isApplicable: Serialization.isFunctypeValue,
 *     serialize:   Serialization.toEnvelope,
 *     deserialize: (o) => Serialization.fromEnvelope(o).orThrow(),
 *   })
 */
declare const toEnvelope: (value: unknown) => JSONValue;
/**
 * Inverse of `toEnvelope`: reconstruct any value from a parsed JSON envelope
 * (object/array/primitive). Equivalent to `deserialize(JSON.stringify(envelope))`
 * but skips the stringify/parse roundtrip — the same `revive` walker is
 * applied directly. Returns `Try` for the same reasons as `deserialize`.
 *
 * Pass-through policy matches `deserialize`: a parsed value without an
 * `@functype` marker is returned verbatim as `Success(value)`.
 *
 * Input is `unknown` (intentionally permissive — Postel's law). Host
 * serializers typically hand the deserialize callback a JSON-shaped value
 * that they parsed themselves, but their callback typing varies (some are
 * `JSONValue`, some are `unknown`, some are `any`). Accepting `unknown`
 * here means the function slots into any host shape without forcing a
 * cast at the consumer site.
 */
declare const fromEnvelope: (envelope: unknown) => Try<unknown>;
/**
 * Runtime guard: is this a live functype Serializable? Checks for the
 * `serialize()` method plus the `_tag` field that every Serializable instance
 * carries. Use this when wrapping `serialize`/`deserialize` in a host
 * serializer that needs to distinguish functype values from foreign data
 * (e.g. `isApplicable` in a DBOS recipe).
 */
declare const isFunctypeValue: (v: unknown) => v is Serializable<unknown>;
//#endregion
//#region src/try/Try.d.ts
/**
 * Possible types of Try instances
 */
type TypeNames = "Success" | "Failure";
interface Try<out T> extends FunctypeSum<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<T2 extends Type>(defaultValue: T2): T | T2;
  orThrow: (error?: Error) => T;
  /**
   * Returns the success value, or calls the never-returning handler with the Failure's error.
   * Use this when you have a helper like `(msg) => fail(msg, 2)` that terminates the program —
   * the result type is unconditionally `T`, so you avoid the TypeScript narrowing trap where
   * `if (t.isFailure()) fail(...)` fails to narrow `t.value` when `fail` is an arrow function
   * typed as `(...): never`.
   */
  expect: (handler: (error: Error) => never) => T;
  or<T2 extends Type>(alternative: Try<T2>): Try<T | T2>;
  orNull: () => T | null;
  orUndefined: () => T | undefined;
  toOption: () => Option<T>;
  /**
   * Converts to a plain readonly array: `[value]` for Success, `[]` for Failure.
   * Symmetric with `Try.toList()` but skips the List wrapper for code that
   * just wants to feed Array.prototype methods or spread into another array.
   */
  toArray: () => readonly T[];
  /**
   * Converts to Either<E, T>. Failure becomes Left(builder(error)) when given a function,
   * or Left(leftValue) when given a value. Success becomes Right(value).
   *
   * Prefer the function form to thread the underlying Error's context into the Left:
   *
   *   Try.fromYAML(text).toEither((e) => `parse failed: ${e.message}`)
   */
  toEither: <E extends Type>(leftOrBuilder: E | ((err: Error) => E)) => Either<E, 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;
  /**
   * Async variant of fold. Accepts sync or async handlers on either branch and
   * always returns a Promise.
   */
  foldAsync: <U extends Type>(onFailure: (error: Error) => U | Promise<U>, onSuccess: (value: T) => U | Promise<U>) => Promise<U>;
  toString: () => string;
  /**
   * Pattern matches over the Try, applying a handler function based on the variant
   * @param patterns - Object with handler functions for Success and Failure variants
   * @returns The result of applying the matching handler function
   */
  match<R>(patterns: {
    Success: (value: T) => R;
    Failure: (error: Error) => R;
  }): R;
  /**
   * Recovers from a Failure by applying a function to the error, returning a new Try.
   * The recovery value may be a wider type; the result is `Try<T | U>`, matching
   * Scala's `recover[U >: T]` shape so Try stays covariant in T.
   */
  recover<U extends Type>(f: (error: Error) => U): Try<T | U>;
  /**
   * Recovers from a Failure by applying a function that returns a new Try.
   * As with `recover`, the recovery Try may carry a wider type; the result widens accordingly.
   */
  recoverWith<U extends Type>(f: (error: Error) => Try<U>): Try<T | U>;
  /**
   * Applies a predicate to the success value. If the predicate fails, short-circuits
   * to a Failure with the error produced by `onUnsatisfied`. Failure passes through
   * unchanged (predicate not evaluated). Lets you turn a value-level guard into the
   * error channel without writing a manual `throw` inside a `Try(() => ...)` body.
   * @param predicate - The predicate to test the success value
   * @param onUnsatisfied - Builds the Error for the new Failure when the predicate fails
   * @returns A Success if the predicate holds, a Failure carrying `onUnsatisfied(value)` otherwise
   */
  filterOrElse(predicate: (value: T) => boolean, onUnsatisfied: (value: T) => Error): Try<T>;
  toValue(): {
    _tag: TypeNames;
    value: T | Error;
  };
  /**
   * Custom JSON serialization. Success emits `{"@functype":"Try","_tag":"Success","value":T}`.
   * Failure emits `{"@functype":"Try","_tag":"Failure","error":SerializedError}` where
   * SerializedError captures `name`, `message`, `stack`, and the full `cause` chain —
   * `e.name` survives round-trip but `instanceof SomeError` does not.
   */
  toJSON(): {
    "@functype": "Try";
    _tag: "Success";
    value: T;
  } | {
    "@functype": "Try";
    _tag: "Failure";
    error: SerializedError;
  };
}
declare const Try: (<T>(f: () => T) => Try<T>) & {
  /**
   * Creates a Success directly without needing a callback
   * @param value - The success value
   * @returns Try containing the value as Success
   */
  success: <T>(value: T) => Try<T>;
  /**
   * Creates a Failure directly without needing to throw
   * @param error - The error (string or Error instance)
   * @returns Try containing the error as Failure
   */
  failure: <T>(error: Error | string) => Try<T>;
  /**
   * Creates a Try from a Promise, resolving to Success or Failure
   * @param promise - The promise to convert
   * @returns Promise resolving to a Try
   */
  fromPromise: <T>(promise: Promise<T>) => Promise<Try<T>>;
  /**
   * Creates a Try from a thunk that returns a Promise. The thunk is invoked
   * when async() is called, so the Promise starts executing under the Try
   * wrapper — synchronous throws from the thunk are caught the same way
   * `Try(() => sync)` catches them, and rejections are caught the same way
   * `Try.fromPromise(promise)` catches them.
   *
   * Prefer this over `Try.fromPromise(thunk())` when you want the work to be
   * deferred until wrapping (e.g. composing a chain of Try-returning thunks
   * before any of them runs).
   *
   * @example
   *   const result = await Try.async(() => fs.readFile(path, "utf8"))
   *   result.fold(err => log(err.message), data => process(data))
   *
   * @param thunk - Function returning a Promise to be wrapped
   * @returns Promise resolving to a Try
   */
  async: <T>(thunk: () => Promise<T>) => Promise<Try<T>>;
  /**
   * Type guard to check if a Try is Success
   * @param tryValue - The Try to check
   * @returns True if Try is Success
   */
  isSuccess: <T>(tryValue: Try<T>) => tryValue is Try<T> & {
    readonly _tag: "Success";
    error: undefined;
  };
  /**
   * Type guard to check if a Try is Failure
   * @param tryValue - The Try to check
   * @returns True if Try is Failure
   */
  isFailure: <T>(tryValue: Try<T>) => tryValue is Try<T> & {
    readonly _tag: "Failure";
    error: Error;
  };
  /**
   * Creates a Try from JSON string
   * @param json - The JSON string
   * @returns Try instance
   */
  fromJSON: <T>(json: string) => Try<T>;
  /**
   * Creates a Try from YAML string
   * @param yaml - The YAML string
   * @returns Try instance
   */
  fromYAML: <T>(yaml: string) => Try<T>;
  /**
   * Creates a Try from binary string
   * @param binary - The binary string
   * @returns Try instance
   */
  fromBinary: <T>(binary: string) => Try<T>;
  /**
   * Combines an array of Trys into a single Try containing an array.
   * Short-circuits on the first Failure, preserving its error.
   * @param tries - Array of Try values
   * @returns Success with array of values, or first Failure
   */
  sequence: <T>(tries: Try<T>[]) => Try<T[]>;
  /**
   * Maps an array through a function returning Try, then sequences the results.
   * Short-circuits on the first Failure.
   * @param arr - Array of values
   * @param f - Function returning Try
   * @returns Success with array of mapped values, or first Failure
   */
  traverse: <T, U>(arr: ReadonlyArray<T>, f: (value: T, index: number) => Try<U>) => Try<U[]>;
};
//#endregion
//#region src/reshapeable/Reshapeable.d.ts
/**
 * Interface for types that can be reshaped (converted) between different monadic containers.
 * Provides standard conversion methods to transform between Option, Either, List, and Try types.
 *
 * @typeParam T - The type of the value contained in the monad
 *
 * @example
 * // Convert Option to Either
 * const opt = Option(5)
 * const either = opt.toEither("None value")  // Right(5)
 *
 * @example
 * // Convert Either to Option
 * const right = Right(10)
 * const option = right.toOption()  // Some(10)
 *
 * @example
 * // Convert List to Try
 * const list = List([1, 2, 3])
 * const tryVal = list.toTry()  // Success(1) - uses first element
 *
 * @example
 * // Use with Do comprehensions
 * const result = Do(function* () {
 *   const x = yield* $(Option(5))
 *   const y = yield* $(Right<string, number>(10))
 *   return x + y
 * })
 *
 * // Convert to desired type for chaining
 * const asOption = result.toOption()
 * asOption.map(x => x * 2).orElse(0)
 */
interface Reshapeable<out 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(leftValue). Try also accepts a builder
   *   `(err: Error) => E` to thread the underlying Error's context into the Left.
   *
   * @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>;
}
//#endregion
//#region src/list/List.d.ts
/**
 * Immutable List. Covariant in A (`<out A>`) — mirrors Scala's `List[+A]`.
 *
 * Methods that would otherwise force A-invariance use TS equivalents of Scala's
 * co-variance patterns:
 *   - query/removal ops (`contains`, `indexOf`, `remove`) take `unknown`, matching
 *     Scala's `-(elem: Any)` / `contains(elem: Any)` — if the value can't possibly
 *     be in the list, it's a no-op, not a type error.
 *   - additive ops (`add`, `prepend`, `concat`) widen the element type, matching
 *     Scala's `::[B >: A]` / `++[B >: A]` — `List<A> + B` produces `List<A | B>`.
 *   - `reduce` / `reduceRight` accept a wider accumulator type, matching Scala's
 *     `reduce[B >: A]`.
 */
interface List<out 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 a value. Accepts `unknown` so an unrelated-type arg is a safe no-op (Scala: `-(elem: Any)`). */
  remove: (value: unknown) => List<A>;
  removeAt: (index: number) => List<A>;
  /** Add a value, possibly widening the element type (Scala: `:+[B >: A]`). */
  add<B>(item: B): List<A | B>;
  get: (index: number) => Option<A>;
  /** Concatenate with another list, possibly widening (Scala: `++[B >: A]`). */
  concat<B>(other: List<B>): List<A | B>;
  take: (n: number) => List<A>;
  takeWhile: (p: (a: A) => boolean) => List<A>;
  takeRight: (n: number) => List<A>;
  get last(): A | undefined;
  get lastOption(): Option<A>;
  get tail(): List<A>;
  get init(): List<A>;
  reverse: () => List<A>;
  /** Find the index of a value. Accepts `unknown` (Scala: `indexOf(elem: Any)`). */
  indexOf: (value: unknown) => number;
  /** Prepend a value, possibly widening (Scala: `+:[B >: A]`). */
  prepend<B>(item: B): List<A | B>;
  distinct: () => List<A>;
  sorted: (compareFn?: (a: A, b: A) => number) => List<A>;
  sortBy: <B>(f: (a: A) => B, compareFn?: (a: B, b: B) => number) => List<A>;
  zip: <B>(other: List<B>) => List<[A, B]>;
  zipWithIndex: () => List<[A, number]>;
  groupBy: <K>(f: (a: A) => K) => globalThis.Map<K, List<A>>;
  partition: (p: (a: A) => boolean) => [List<A>, List<A>];
  span: (p: (a: A) => boolean) => [List<A>, List<A>];
  slice: (start: number, end: number) => List<A>;
  /**
   * Pattern matches over the List, applying a handler function based on whether it's empty
   * @param patterns - Object with handler functions for Empty and NonEmpty variants
   * @returns The result of applying the matching handler function
   */
  match<R>(patterns: {
    Empty: () => R;
    NonEmpty: (values: A[]) => R;
  }): R;
}
declare const List: (<A>(values?: Iterable<A>) => List<A>) & {
  /**
   * Creates an empty List
   * Returns a singleton instance for efficiency
   * @returns An empty List instance
   */
  empty: <A extends Type>() => List<A>;
  /**
   * Creates a List from variadic arguments
   * @param values - Values to create list from
   * @returns A List containing the values
   */
  of: <A extends Type>(...values: A[]) => List<A>;
  /**
   * Creates a List from JSON string
   * @param json - The JSON string
   * @returns List instance
   */
  fromJSON: <A>(json: string) => List<A>;
  /**
   * Creates a List from YAML string
   * @param yaml - The YAML string
   * @returns List instance
   */
  fromYAML: <A>(yaml: string) => List<A>;
  /**
   * Creates a List from binary string
   * @param binary - The binary string
   * @returns List instance
   */
  fromBinary: <A>(binary: string) => List<A>;
};
//#endregion
//#region src/set/Set.d.ts
/**
 * Immutable Set. Covariant in A (`<out A>`) — while Scala's `Set[A]` is nominally invariant,
 * functype's Set follows the same pragmatic covariance pattern as List: element-query methods
 * (`contains`, `has`, `remove`) accept `unknown`, and additions widen via `<B>(B) => Set<A | B>`.
 * `reduce`/`reduceRight` follow Scala's `reduce[B >: A]` pattern with a default `B = A`.
 */
interface Set<out A> extends FunctypeCollection<A, "Set">, Collection<A> {
  add<B>(value: B): Set<A | B>;
  remove: (value: unknown) => Set<A>;
  has(value: unknown): 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: <B>(initial: B, fn: (acc: B, a: A) => B) => B;
  toList: () => List<A>;
  toSet: () => Set<A>;
  toArray: <B = A>() => B[];
  toString: () => string;
}
declare const Set: (<A>(iterable?: Iterable<A>) => Set<A>) & {
  /**
   * Creates an empty Set
   * Returns a singleton instance for efficiency
   * @returns An empty Set instance
   */
  empty: <A extends Type>() => Set<A>;
  /**
   * Creates a Set from variadic arguments
   * @param values - Values to create set from
   * @returns A Set containing the unique values
   */
  of: <A extends Type>(...values: A[]) => Set<A>;
  /**
   * Creates a Set from JSON string
   * @param json - The JSON string
   * @returns Set instance
   */
  fromJSON: <A>(json: string) => Set<A>;
  /**
   * Creates a Set from YAML string
   * @param yaml - The YAML string
   * @returns Set instance
   */
  fromYAML: <A>(yaml: string) => Set<A>;
  /**
   * Creates a Set from binary string
   * @param binary - The binary string
   * @returns Set instance
   */
  fromBinary: <A>(binary: string) => Set<A>;
};
//#endregion
//#region src/collections/index.d.ts
/**
 * Represents a collection with conversion capabilities
 * @interface
 * @module Collections
 * @category Core
 */
interface Collection<A> {
  toList(): List<A>;
  toSet(): Set<A>;
  toString(): string;
}
//#endregion
//#region src/matchable/Matchable.d.ts
/**
 * Pattern matching interface for functional data types.
 *
 * @typeParam A - The type of elements in the data structure
 * @typeParam Tags - The type of tags used for pattern matching
 */
interface Matchable<out 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;
};
//#endregion
//#region src/traversable/Traversable.d.ts
/**
 * Traversable typeclass for data structures that can be traversed through.
 *
 * Covariance: A is declared `<out A>`. Query (`contains`) accepts `unknown` —
 * mirroring Scala's `contains(elem: Any)` — so an unrelated-type arg is a
 * sound `false` rather than a type error. Aggregations (`reduce`, `reduceRight`)
 * widen the accumulator via `<B = A>`, matching Scala's `reduce[B >: A]`; when
 * called without an explicit type arg the behavior is identical to the pre-0.59
 * signature, so existing call sites compile unchanged.
 *
 * Implementers that previously overrode these methods with the widened shape
 * (List, Set) can inherit from this base without a per-type override.
 */
interface Traversable<out A extends Type> extends AsyncMonad<A> {
  get size(): number;
  get isEmpty(): boolean;
  contains(value: unknown): boolean;
  reduce<B = A>(op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>): Widen<A, B>;
  reduceRight<B = A>(op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>): Widen<A, B>;
}
//#endregion
//#region src/functype/Functype.d.ts
/**
 * Base interface for all functype data structures.
 * This provides a standard contract with core functional programming traits.
 *
 * @typeParam A - The type of value contained in the functor
 * @typeParam Tag - The type tag for pattern matching (e.g., "Some" | "None" for Option)
 *
 * @example
 * ```typescript
 * // Implementing FunctypeBase for a custom data structure
 * class MyContainer<T> implements FunctypeBase<T, "Empty" | "Full"> {
 *   // Implementation of all required methods...
 * }
 * ```
 */
interface FunctypeBase<A, Tag extends string = string> extends AsyncMonad<A>, Traversable<A>, Serializable<A>, Foldable<A>, Typeable<Tag>, ContainerOps<A> {
  readonly _tag: Tag;
  readonly [Symbol.toStringTag]: string;
}
/**
 * Interface for single-value containers like Option, Either, Try.
 * Extends FunctypeBase with extraction methods and Pipe.
 *
 * @typeParam A - The type of value contained
 * @typeParam Tag - The type tag for pattern matching
 */
interface Functype<A, Tag extends string = string> extends FunctypeBase<A, Tag>, Extractable<A>, Pipe<A>, Matchable<A, Tag> {
  toValue(): {
    _tag: Tag;
    value: A;
  };
}
/**
 * A version of Functype for collection types that need iteration support.
 * Extends FunctypeBase with Iterable protocol but without Extractable.
 *
 * @typeParam A - The element type of the collection
 * @typeParam Tag - The type tag for pattern matching
 */
interface FunctypeCollection<A, Tag extends string = string> extends Omit<FunctypeBase<A, Tag>, "flatMapAsync" | "flatMap">, Iterable<A>, Pipe<A[]>, Collection<A>, CollectionOps<A, FunctypeCollection<A, Tag>> {
  toValue(): {
    _tag: Tag;
    value: A[];
  };
  flatMap<B extends Type>(f: (value: A) => Iterable<B>): FunctypeCollection<B, Tag>;
  flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Iterable<B>>): PromiseLike<FunctypeCollection<B, Tag>>;
}
//#endregion
//#region src/functype/FunctypeSum.d.ts
/**
 * Base interface for sum-type containers (Either, Try, etc.) that are NOT iterables.
 *
 * Unlike `FunctypeBase`, this base deliberately excludes `Traversable` — which bundles
 * `reduce` / `reduceRight` / `size` / `isEmpty`. Those methods force A-invariance on their
 * containers (signature `(f: (A, A) => A) => A` puts A in both contravariant and covariant
 * positions) and have no semantic meaning for disjoint-union types where the "success"
 * branch is 0-or-1, not a collection.
 *
 * Sum types that extend `FunctypeSum` can be declared covariant in their type parameter
 * (`interface Foo<out A>`) without structural check failures. This mirrors Scala's model:
 * `Either[+L, +R]` and `Try[+T]` do not extend `Iterable`; only `Option[+A]` extends the
 * lighter `IterableOnce[+A]`.
 *
 * Only the covariance-safe subset of `ContainerOps` is included inline: `contains`,
 * `exists`, and `forEach` all place A only in contravariant (callback input) position.
 * `find` (returns `Option<A>`) and `count` are intentionally omitted — if a sum type
 * needs them it can declare them directly.
 *
 * @typeParam A - the type of the "success" branch value
 * @typeParam Tag - the discriminant tag (e.g., `"Left" | "Right"`, `"Success" | "Failure"`)
 */
interface FunctypeSum<A extends Type, Tag extends string = string> extends AsyncMonad<A>, Foldable<A>, Serializable<A>, Typeable<Tag> {
  readonly _tag: Tag;
  readonly [Symbol.toStringTag]: string;
  contains(value: A): boolean;
  exists(p: (a: A) => boolean): boolean;
  forEach(f: (a: A) => void): void;
}
//#endregion
//#region src/branded/ValidatedBrand.d.ts
type ValidatedBrand<K extends string, T> = Brand<K, T> & {
  readonly __validated: true;
};
interface ValidatedBrandCompanion<K extends string, T> {
  readonly brand: K;
  readonly validate: (value: T) => boolean;
  readonly of: (value: T) => Option<ValidatedBrand<K, T>>;
  readonly from: (value: T) => Either<string, ValidatedBrand<K, T>>;
  readonly unsafeOf: (value: T) => ValidatedBrand<K, T>;
  readonly is: (value: unknown) => value is ValidatedBrand<K, T>;
  readonly unwrap: (branded: Brand<K, T>) => T;
  readonly refine: <K2 extends string>(brand: K2, validate: (value: Brand<K, T>) => boolean) => ValidatedBrandCompanion<K2, Brand<K, T>>;
}
/**
 * Create a validated brand with runtime validation
 * @example
 * const Email = ValidatedBrand("Email", (s: string) => /^[^@]+@[^@]+\.[^@]+$/.test(s))
 * const email = Email.of("user@example.com") // Some(Brand<"Email", string>)
 *
 * @example
 * // With Either for error messages
 * const Port = ValidatedBrand("Port", (n: number) => n >= 1 && n <= 65535)
 * const result = Port.from(8080) // Right(Brand<"Port", number>)
 * const error = Port.from(70000) // Left("Invalid Port: validation failed")
 *
 * @example
 * // Type guard usage
 * const value: unknown = "test@example.com"
 * if (Email.is(value)) {
 *   // value is Brand<"Email", string>
 * }
 *
 * @example
 * // Best Practice: Use same brand name for seamless conversion
 * // ValidatedBrand extends Brand, so when using the same brand name,
 * // no casting is needed for conversion
 * const ValidatedUserId = ValidatedBrand("UserId", (s: string) => s.length > 0)
 * type ValidatedUserId = ReturnType<typeof ValidatedUserId.of> extends Option<infer T> ? T : never
 * type UserId = Brand<"UserId", string>
 *
 * const toSimpleUserId = (id: ValidatedUserId): UserId => id // No cast needed!
 *
 * // Avoid different brand names which require casting:
 * // ❌ ValidatedBrand("ValidatedUserId", ...) + Brand<"UserId", string>
 * // ✅ ValidatedBrand("UserId", ...) + Brand<"UserId", string>
 */
declare function ValidatedBrand<K extends string, T>(brand: K, validate: (value: T) => boolean): ValidatedBrandCompanion<K, T>;
/**
 * Positive number brand (> 0)
 * @example
 * const price = PositiveNumber.of(19.99) // Some(Brand<"PositiveNumber", number>)
 * const invalid = PositiveNumber.of(-5) // None
 * const checked = PositiveNumber.from(0) // Left("Invalid PositiveNumber: validation failed")
 */
declare const PositiveNumber: ValidatedBrandCompanion<"PositiveNumber", number>;
declare const NonNegativeNumber: ValidatedBrandCompanion<"NonNegativeNumber", number>;
declare const IntegerNumber: ValidatedBrandCompanion<"IntegerNumber", number>;
declare const PositiveInteger: ValidatedBrandCompanion<"PositiveInteger", Brand<"PositiveNumber", number>>;
/**
 * Non-empty string brand
 * @example
 * const name = NonEmptyString.of("John") // Some(Brand<"NonEmptyString", string>)
 * const empty = NonEmptyString.of("") // None
 */
declare const NonEmptyString: ValidatedBrandCompanion<"NonEmptyString", string>;
/**
 * Email address brand with basic validation
 * @example
 * const email = EmailAddress.of("user@example.com") // Some(Brand<"EmailAddress", string>)
 * const invalid = EmailAddress.of("not-an-email") // None
 *
 * @example
 * // Using with forms
 * const processEmail = (input: string) => {
 *   return EmailAddress.from(input)
 *     .map(email => sendWelcomeEmail(email))
 *     .orElse("Invalid email address")
 * }
 */
declare const EmailAddress: ValidatedBrandCompanion<"EmailAddress", string>;
declare const UrlString: ValidatedBrandCompanion<"UrlString", string>;
declare const UUID: ValidatedBrandCompanion<"UUID", string>;
declare const ISO8601Date: ValidatedBrandCompanion<"ISO8601Date", string>;
/**
 * Create a number brand with min/max bounds
 * @example
 * const Percentage = BoundedNumber("Percentage", 0, 100)
 * const valid = Percentage.of(75) // Some(Brand<"Percentage", number>)
 * const invalid = Percentage.of(150) // None
 *
 * @example
 * const Port = BoundedNumber("Port", 1, 65535)
 * const httpPort = Port.unsafeOf(80) // Brand<"Port", number>
 * // Port.unsafeOf(70000) // throws Error
 */
declare function BoundedNumber(brand: string, min: number, max: number): ValidatedBrandCompanion<string, number>;
/**
 * Create a string brand with length constraints
 * @example
 * const Username = BoundedString("Username", 3, 20)
 * const valid = Username.of("johndoe") // Some(Brand<"Username", string>)
 * const tooShort = Username.of("jo") // None
 * const tooLong = Username.of("verylongusernamethatexceedslimit") // None
 */
declare function BoundedString(brand: string, minLength: number, maxLength: number): ValidatedBrandCompanion<string, string>;
/**
 * Create a string brand that matches a regex pattern
 * @example
 * const HexColor = PatternString("HexColor", /^#[0-9a-f]{6}$/i)
 * const red = HexColor.of("#ff0000") // Some(Brand<"HexColor", string>)
 * const invalid = HexColor.of("red") // None
 *
 * @example
 * const PhoneNumber = PatternString("PhoneNumber", /^\+?[1-9]\d{1,14}$/)
 * const phone = PhoneNumber.from("+1234567890")
 *   .map(p => formatPhoneNumber(p))
 *   .orElse("Invalid phone number")
 */
declare function PatternString(brand: string, pattern: RegExp): ValidatedBrandCompanion<string, string>;
//#endregion
//#region src/core/base/Base.d.ts
/**
 * Base Object from which most other objects inherit
 * Now includes automatic Do-notation support via doUnwrap method
 * @param type - The type name for the object
 * @param body - The implementation body
 */
declare function Base<T extends Record<string, unknown>>(type: string, body: T): T & {
  toString(): string;
  doUnwrap(): DoResult<unknown>;
  _tag: string;
};
//#endregion
//#region src/core/throwable/Throwable.d.ts
/**
 * The identifier name for Throwable type
 */
declare const NAME: "Throwable";
/**
 * @internal
 */
type ThrowableType = Error & Typeable<typeof NAME> & {
  readonly data?: unknown;
  readonly cause?: Error;
  readonly taskInfo?: {
    name: string;
    description: string;
  };
};
declare class Throwable extends Error implements ThrowableType {
  readonly _tag: typeof NAME;
  readonly data?: unknown;
  readonly cause?: Error;
  readonly taskInfo?: {
    name: string;
    description: string;
  };
  protected constructor(message: string, options?: {
    data?: unknown | undefined;
    cause?: Error | undefined;
    stack?: string | undefined;
    taskInfo?: {
      name: string;
      description: string;
    } | undefined;
  });
  static apply(srcError: unknown, data?: unknown, taskInfo?: {
    name: string;
    description: string;
  }): ThrowableType;
}
//#endregion
//#region src/core/task/Task.d.ts
/**
 * Type definition for errors with a _tag property that identifies them as Throwables
 */
type TaggedThrowable = Error & {
  _tag: "Throwable";
  cause?: Error;
  taskInfo?: {
    name: string;
    description: string;
  };
};
/**
 * Type guard to check if an error is a TaggedThrowable
 */
declare function isTaggedThrowable(error: unknown): error is TaggedThrowable;
interface TaskParams {
  readonly name?: string;
  readonly description?: string;
}
interface TaskMetadata {
  readonly name: string;
  readonly description: string;
}
interface TaskOutcome<out T> extends FunctypeBase<T, "Ok" | "Err">, Extractable<T>, AsyncMonad<T>, Promisable<T>, Doable<T> {
  readonly _tag: "Ok" | "Err";
  readonly _meta: TaskMetadata;
  readonly value?: T;
  readonly error?: Throwable;
  readonly map: <U>(f: (value: T) => U) => TaskOutcome<U>;
  readonly flatMap: <U>(f: (value: T) => TaskOutcome<U> | Either<Throwable, U>) => TaskOutcome<U>;
  readonly ap: <U>(ff: TaskOutcome<(value: T) => U>) => TaskOutcome<U>;
  readonly mapAsync: <U>(f: (value: T) => Promise<U>) => Promise<TaskOutcome<U>>;
  readonly flatMapAsync: <U>(f: (value: T) => Promise<TaskOutcome<U>>) => Promise<TaskOutcome<U>>;
  readonly mapError: (f: (error: Throwable) => Throwable) => TaskOutcome<T>;
  recover<U extends Type>(value: U): Ok<T | U>;
  recoverWith<U extends Type>(f: (error: Throwable) => U): Ok<T | U>;
  readonly isSuccess: () => this is Ok<T>;
  readonly isFailure: () => this is Err<T>;
  readonly isOk: () => this is Ok<T>;
  readonly isErr: () => this is Err<T>;
  readonly toEither: () => Either<Throwable, T>;
  readonly toTry: () => Try<T>;
  readonly toOption: () => Option<T>;
  readonly toList: () => List<T>;
  readonly fold: <U>(onErr: (error: Throwable) => U, onOk: (value: T) => U) => U;
  readonly match: <U>(patterns: {
    Ok: (value: T) => U;
    Err: (error: Throwable) => U;
  }) => U;
  /**
   * Custom JSON serialization. Ok emits `{"@functype":"Task","_tag":"Ok","value":T}`.
   * Err emits `{"@functype":"Task","_tag":"Err","error":SerializedError}` capturing the
   * Throwable's name, message, stack, and cause chain. See error-envelope.ts —
   * `instanceof` does NOT survive round-trip but `error.name` does.
   */
  toJSON(): {
    "@functype": "Task";
    _tag: "Ok";
    value: T;
  } | {
    "@functype": "Task";
    _tag: "Err";
    error: SerializedError;
  };
}
interface Ok<out T> extends TaskOutcome<T> {
  readonly _tag: "Ok";
  readonly value: T;
  readonly error: undefined;
}
interface Err<out T> extends TaskOutcome<T> {
  readonly _tag: "Err";
  readonly value: undefined;
  readonly error: Throwable;
}
type TaskSuccess<T> = Ok<T>;
type TaskFailure<T> = Err<T>;
/**
 * Err constructor - Creates a failed TaskOutcome
 * @param error - The error object
 * @param data - Additional data related to the error
 * @param params - Task parameters
 */
declare const Err: <T>(error: unknown, data?: unknown, params?: TaskParams) => Err<T>;
/**
 * Ok constructor - Creates a successful TaskOutcome
 * @param data - The successful value
 * @param params - Task parameters
 */
declare const Ok: <T>(data: T, params?: TaskParams) => Ok<T>;
type TaskResult<T> = Promise<TaskOutcome<T>>;
/**
 * The CancellationToken is a control structure that allows long-running tasks to be cancelled
 * Cancellation is cooperative, meaning the task must check the token and respond to cancellation requests
 */
type CancellationToken = {
  /** Whether the token has been cancelled */
  readonly isCancelled: boolean;
  /** Signal that can be used with fetch and other abortable APIs */
  readonly signal: AbortSignal;
  /** Register a callback to be called when cancellation occurs */
  onCancel(callback: () => void): void;
};
/**
 * Create a cancellation token and controller
 * The controller can be used to cancel operations that use the token
 */
type CancellationTokenSource = {
  /** The token to be passed to cancellable operations */
  readonly token: CancellationToken;
  /** Cancel all operations using this token */
  cancel(): void;
};
/**
 * Create a cancellation token source
 * @returns A CancellationTokenSource that can be used to create and control cancellation tokens
 */
declare const createCancellationTokenSource: () => CancellationTokenSource;
type Sync<T> = TaskOutcome<T>;
type Async<T> = TaskResult<T>;
declare const Task$1: (<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
   *
   * @param t - The main operation function that returns a value or Promise
   * @param e - Optional error handler function
   * @param f - Optional finally handler function
   * @param cancellationToken - Optional token for cancellation support
   */
  Async: <U = T>(t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => Promise<TaskOutcome<U>>;
  /**
   * Run a synchronous operation with explicit try/catch/finally semantics
   * Returns a TaskOutcome for functional error handling
   *
   * @param t - The main operation function that returns a value
   * @param e - Optional error handler function
   * @param f - Optional finally handler function
   */
  Sync: <U = T>(t: () => U, e?: (error: unknown) => unknown, f?: () => void) => TaskOutcome<U>;
  /**
   * Run an async operation with progress tracking capabilities
   * Returns a Promise and provides progress updates via callback
   *
   * @param t - The main operation that receives a progress updater function
   * @param onProgress - Callback that receives progress updates (0-100)
   * @param e - Optional error handler function
   * @param f - Optional finally handler function
   * @param cancellationToken - Optional token for cancellation support
   */
  AsyncWithProgress: <U = T>(t: (updateProgress: (percent: number) => void) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, onProgress: (percent: number) => void, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => Promise<TaskOutcome<U>>;
  toString(): string;
  doUnwrap(): DoResult<unknown>;
  _tag: string;
}) & {
  /**
   * Create a successful Task result
   */
  success: <T>(data: T, params?: TaskParams) => Ok<T>;
  /**
   * Create a failed Task result
   */
  fail: <T>(error: unknown, data?: unknown, params?: TaskParams) => Err<T>;
  /**
   * Create a successful Task result (alias for success)
   * Preferred for new code
   */
  ok: <T>(data: T, params?: TaskParams) => Ok<T>;
  /**
   * Create a failed Task result (alias for fail)
   * Preferred for new code
   */
  err: <T>(error: unknown, data?: unknown, params?: TaskParams) => Err<T>;
  /**
   * Reconstruct a TaskOutcome from a JSON envelope emitted by `serialize().toJSON()`
   * or instance `toJSON()`. Verifies `@functype === "Task"` and dispatches on `_tag`.
   *
   * Err reconstruction goes through `deserializeError` so `name`/`message`/`stack`/`cause`
   * survive; the resulting Throwable carries the deserialized Error as its underlying
   * error (subclass identity does NOT round-trip — see error-envelope.ts).
   */
  fromJSON: <T>(json: string) => TaskOutcome<T>;
  /**
   * Create TaskOutcome from Either
   * @param either - Either to convert
   * @param params - Task parameters
   */
  fromEither: <T>(either: Either<Throwable, T>, params?: TaskParams) => TaskOutcome<T>;
  /**
   * Create TaskOutcome from Try
   * @param tryValue - Try to convert
   * @param params - Task parameters
   */
  fromTry: <T>(tryValue: Try<T>, params?: TaskParams) => TaskOutcome<T>;
  /**
   * Extract the error chain from a Throwable error
   * Returns an array of errors from outermost to innermost
   *
   * @param error - The error to extract the chain from
   * @returns An array of errors in the chain, from outermost to innermost
   */
  getErrorChain: (error: Error | undefined) => Error[];
  /**
   * Format the error chain as a string with the option to include task details
   *
   * @param error - The error to format
   * @param options - Formatting options
   * @returns A formatted string representation of the error chain
   */
  formatErrorChain: (error: Error | undefined, options?: {
    includeTasks?: boolean;
    separator?: string;
    includeStackTrace?: boolean;
  }) => string;
  /**
   * Convert a Promise-returning function to a Task-compatible function
   */
  fromPromise: <U, Args extends unknown[]>(promiseFn: (...args: Args) => Promise<U>, params?: TaskParams) => ((...args: Args) => Promise<TaskOutcome<U>>);
  /**
   * Convert a Task result to a Promise
   */
  toPromise: <U>(taskOutcome: TaskOutcome<U>) => Promise<U>;
  /**
   * Race multiple tasks and return the result of the first one to complete
   * Optionally specify a timeout after which the race will fail
   *
   * @param tasks - Array of tasks to race (as Promises)
   * @param timeoutMs - Optional timeout in milliseconds
   * @param params - Task parameters for the race operation
   * @returns A promise that resolves with the first task to complete or rejects if all tasks fail
   */
  race: <T>(tasks: Array<Promise<T> | Promise<TaskOutcome<T>>>, timeoutMs?: number, params?: TaskParams) => Promise<TaskOutcome<T>>;
  /**
   * Convert a Node.js style callback function to a Task-compatible function
   * Node.js callbacks typically have the signature (error, result) => void
   *
   * @param nodeFn - Function that accepts a Node.js style callback
   * @param params - Task parameters
   * @returns A function that returns a Promise
   */
  fromNodeCallback: <T, Args extends unknown[]>(nodeFn: (...args: [...Args, (error: unknown, result: T) => void]) => void, params?: TaskParams) => ((...args: Args) => Promise<TaskOutcome<T>>);
  /**
   * Create a cancellation token source
   * @returns A cancellation token source that can be used to control task cancellation
   */
  createCancellationTokenSource: () => CancellationTokenSource;
  /**
   * Create a task that can be cancelled
   *
   * @param task - The task function to make cancellable
   * @param params - Task parameters
   * @returns An object with the task and a function to cancel it
   */
  cancellable: <T>(task: (token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>, params?: TaskParams) => {
    task: Promise<TaskOutcome<T>>;
    cancel: () => void;
  };
  /**
   * Creates a task with progress tracking
   *
   * @param task - The task function that accepts a progress updater
   * @param onProgress - Callback function that receives progress updates
   * @param params - Task parameters
   * @returns An object with the task, cancel function, and current progress
   */
  withProgress: <T>(task: (updateProgress: (percent: number) => void, token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>, onProgress?: (percent: number) => void, params?: TaskParams) => {
    task: Promise<TaskOutcome<T>>;
    cancel: () => void;
    currentProgress: () => number;
  };
};
type Task$1 = ReturnType<typeof Task$1>;
//#endregion
//#region src/decoder/DecoderError.d.ts
/**
 * Recursive decoder error.
 *
 * `Leaf` represents a single decode failure at some `path` in the input.
 * `Composite` aggregates child failures (one per failed field of an object,
 * one per failed element of a list, etc.) and mirrors the structural shape
 * of the input — making it possible to render `user.name: expected string`
 * alongside `user.age: expected number` from a single response.
 *
 * Accumulation lives in the data, not in the wrapper. Combinators in
 * `DecoderCompanion` (object/list/map) produce `Composite` when more than
 * one child decoder fails, unwrapping single-child composites back to a
 * `Leaf` for cleaner error messages. The plain `Either<DecoderError, A>`
 * return type of `Decoder<A>` keeps composition with the rest of the
 * library uniform.
 *
 * Named `DecoderError` (not `DecodeError`) to avoid collision with the
 * existing `HttpError.DecodeError` variant — these are at different layers:
 * the HTTP variant is the outer wrapper, this is the structural inner cause.
 */
type DecoderError = DecoderErrorLeaf | DecoderErrorComposite;
type DecoderErrorLeaf = {
  readonly _tag: "Leaf";
  readonly path: ReadonlyArray<string>;
  readonly message: string;
  readonly cause?: unknown;
};
type DecoderErrorComposite = {
  readonly _tag: "Composite";
  readonly path: ReadonlyArray<string>;
  readonly children: List<DecoderError>;
};
declare const DecoderError: {
  readonly _tag: "DecoderError";
} & {
  leaf: (path: ReadonlyArray<string>, message: string, cause?: unknown) => DecoderErrorLeaf;
  composite: (path: ReadonlyArray<string>, children: List<DecoderError>) => DecoderErrorComposite;
  isLeaf: (e: DecoderError) => e is DecoderErrorLeaf;
  isComposite: (e: DecoderError) => e is DecoderErrorComposite;
  match: <T>(e: DecoderError, patterns: {
    readonly Leaf: (e: DecoderErrorLeaf) => T;
    readonly Composite: (e: DecoderErrorComposite) => T;
  }) => T;
  prepend: (segment: string, e: DecoderError) => DecoderError;
  flatten: (e: DecoderError) => List<{
    readonly path: ReadonlyArray<string>;
    readonly message: string;
  }>;
  format: (e: DecoderError) => string;
};
//#endregion
//#region src/decoder/Decoder.d.ts
/**
 * A `Decoder<A>` converts an `unknown` value into either a typed `A` or a
 * structural `DecoderError`. The shape `(raw) => Either<DecoderError, A>` is
 * the canonical FP decoder contract (cf. circe `Decoder`, fp-ts `Decoder`,
 * Effect-TS `Schema.decodeUnknownEither`, Elm `Json.Decode.Decoder`).
 *
 * Any function matching this signature IS a decoder — there is no plugin
 * registration. Zod / TypeBox / Valibot / AJV / hand-rolled adapters are
 * ~15 lines each. The bundled combinators in `DecoderCompanion` cover the
 * functype-aware cases (Option, Either, List, etc.) that a generic schema
 * library cannot express.
 */
type Decoder$1<A> = (raw: unknown) => Either<DecoderError, A>;
//#endregion
//#region src/decoder/index.d.ts
/**
 * A `Decoder<A>` converts an `unknown` value into either a typed `A` or a
 * structural `DecoderError`. The shape `(raw) => Either<DecoderError, A>` is
 * the canonical FP decoder contract (cf. circe `Decoder`, fp-ts `Decoder`,
 * Effect-TS `Schema.decodeUnknownEither`, Elm `Json.Decode.Decoder`).
 *
 * Any function matching this signature IS a decoder — there is no plugin
 * registration. Zod / TypeBox / Valibot / AJV / hand-rolled adapters are
 * ~15 lines each. The bundled combinators in the `Decoder` value namespace
 * cover the functype-aware cases (Option, Either, List, etc.) that a
 * generic schema library cannot express.
 */
type Decoder<A> = (raw: unknown) => Either<DecoderError, A>;
/**
 * Decoder namespace: combinators for converting `unknown` into typed values.
 *
 * - `Decoder.string` / `.number` / `.boolean` / `.unknown` / `.nullable(inner)` — leaf primitives
 * - `Decoder.option(inner)` — null-bias Option (null → None, else inner → Some)
 * - `Decoder.either.envelope({ok, err})` / `.discriminated({...}, l, r)` — Either variants
 * - `Decoder.list(inner)` / `.array(inner)` / `.map(inner)` / `.object(shape)` — composites; accumulate child failures
 * - `Decoder.tagged.option/either/try/list/map/obj(inner?)` — round-trip the `{_tag, value}` shape
 *   used by functype's built-in `.toJSON()` (for functype-to-functype services)
 */
declare const Decoder: {
  readonly _tag: "Decoder";
} & {
  tagged: {
    option: <A>(inner: Decoder$1<A>) => Decoder$1<Option<A>>;
    either: <L, R>(left: Decoder$1<L>, right: Decoder$1<R>) => Decoder$1<Either<L, R>>;
    try: <A>(inner: Decoder$1<A>) => Decoder$1<Try<A>>;
    list: <A>(inner: Decoder$1<A>) => Decoder$1<List<A>>;
    map: <V>(inner: Decoder$1<V>) => Decoder$1<Map$1<string, V>>;
    obj: <T extends Record<string, unknown>>(shape: { [K in keyof T]: Decoder$1<T[K]>; }) => Decoder$1<T>;
  };
  string: Decoder$1<string>;
  number: Decoder$1<number>;
  boolean: Decoder$1<boolean>;
  unknown: Decoder$1<unknown>;
  nullable: <A>(inner: Decoder$1<A>) => Decoder$1<A | null>;
  option: <A>(inner: Decoder$1<A>) => Decoder$1<Option<A>>;
  either: {
    envelope: <L, R>(shape: {
      ok: Decoder$1<R>;
      err: Decoder$1<L>;
    }) => Decoder$1<Either<L, R>>;
    discriminated: <L, R>(config: {
      tag: string;
      leftTag: string;
      rightTag: string;
    }, left: Decoder$1<L>, right: Decoder$1<R>) => Decoder$1<Either<L, R>>;
  };
  list: <A>(inner: Decoder$1<A>) => Decoder$1<List<A>>;
  array: <A>(inner: Decoder$1<A>) => Decoder$1<A[]>;
  map: <V>(inner: Decoder$1<V>) => Decoder$1<Map$1<string, V>>;
  object: <T extends Record<string, unknown>>(shape: { [K in keyof T]: Decoder$1<T[K]>; }) => Decoder$1<T>;
};
//#endregion
//#region src/do/index.d.ts
type OptionLike = {
  _tag: "Some" | "None";
  isSome(): boolean;
  get(): unknown;
};
type EitherLike = {
  _tag: "Left" | "Right";
  isLeft(): boolean;
  isRight(): boolean;
  value: unknown;
};
type ListLike = {
  _tag: "List";
  toArray(): unknown[];
};
type TryLike = {
  _tag: "Success" | "Failure";
  isSuccess(): boolean;
  get(): unknown;
};
/**
 * Executes a generator-based monadic comprehension
 * Returns the same monad type as the first yielded monad (Scala semantics)
 *
 * - Option comprehensions return Option (None on short-circuit)
 * - Either comprehensions return Either (Left with error on short-circuit)
 * - List comprehensions return List (empty or cartesian product)
 * - Try comprehensions return Try (Failure with error on short-circuit)
 *
 * Type Inference Notes:
 * - TypeScript infers the correct return type for homogeneous comprehensions
 * - For mixed monad types, TypeScript returns a union type
 * - Use DoTyped<T> or type assertions for mixed scenarios
 *
 * @example
 * ```typescript
 * // Option comprehension returns Option:
 * const result = Do(function* () {
 *   const x = yield* $(Option(5));
 *   const y = yield* $(Option(10));
 *   return x + y;
 * });
 * // result: Option(15)
 *
 * // Either comprehension returns Either:
 * const result = Do(function* () {
 *   const x = yield* $(Right(5));
 *   const y = yield* $(Left("error"));
 *   return x + y;
 * });
 * // result: Left("error") - error is preserved
 *
 * // List comprehension returns List with cartesian product:
 * const result = Do(function* () {
 *   const x = yield* $(List([1, 2]));
 *   const y = yield* $(List([3, 4]));
 *   return x + y;
 * });
 * // result: List([4, 5, 5, 6])
 *
 * // Mixed types - use type assertion or DoTyped:
 * const result = Do(function* () {
 *   const x = yield* $(Option(5));
 *   const y = yield* $(Right<string, number>(10));
 *   return x + y;
 * }) as Option<number>;
 * // result: Option(15)
 * ```
 *
 * @param gen - Generator function that yields monads and returns a result
 * @returns The same monad type as the first yield
 */
declare function Do<T>(gen: () => Generator<OptionLike, T, unknown>): Option<T>;
declare function Do<L, R>(gen: () => Generator<EitherLike, R, unknown>): Either<L, R>;
declare function Do<T>(gen: () => Generator<ListLike, T, unknown>): List<T>;
declare function Do<T>(gen: () => Generator<TryLike, T, unknown>): Try<T>;
declare function Do<T>(gen: () => Generator<OptionLike | EitherLike | ListLike | TryLike, T, unknown>): Reshapeable<T>;
declare function Do<T>(gen: () => Generator<unknown, T, unknown>): unknown;
/**
 * Executes an async generator-based monadic comprehension
 * Returns the same monad type as the first yielded monad
 *
 * @example
 * ```typescript
 * const result = await DoAsync(async function* () {
 *   const user = yield* $(await fetchUser(id));       // Promise<Option<User>> → User
 *   const profile = yield* $(await getProfile(user)); // Promise<Either<Error, Profile>> → Profile
 *   return { user, profile };
 * });
 * // result type matches first yield
 * ```
 *
 * @param gen - Async generator function that yields monads/promises and returns a result
 * @returns Promise of the same monad type as first yield
 */
declare function DoAsync<T>(gen: () => AsyncGenerator<OptionLike, T, unknown>): Promise<Option<T>>;
declare function DoAsync<L, R>(gen: () => AsyncGenerator<EitherLike, R, unknown>): Promise<Either<L, R>>;
declare function DoAsync<T>(gen: () => AsyncGenerator<ListLike, T, unknown>): Promise<List<T>>;
declare function DoAsync<T>(gen: () => AsyncGenerator<TryLike, T, unknown>): Promise<Try<T>>;
declare function DoAsync<T>(gen: () => AsyncGenerator<OptionLike | EitherLike | ListLike | TryLike, T, unknown>): Promise<Reshapeable<T>>;
declare function DoAsync<T>(gen: () => AsyncGenerator<unknown, T, unknown>): Promise<unknown>;
/**
 * Helper function to check if a value implements the Doable interface
 * @param value - Value to check
 * @returns True if the value implements Doable
 */
declare function isDoCapable<T>(value: unknown): value is Doable<T>;
/**
 * Manually unwrap a monad using the Doable interface
 * Useful for testing or when you need to unwrap outside of a Do-comprehension
 *
 * @param monad - Monad to unwrap
 * @returns The unwrapped value
 * @throws Error if the monad cannot be unwrapped
 */
declare function unwrap<T>(monad: Doable<T>): T;
/**
 * Type helper for Do-notation generators.
 * Provides better type hints in IDEs.
 *
 * @example
 * ```typescript
 * const result = Do(function* (): DoGenerator<number> {
 *   const x = yield* $(List([1, 2]))  // x is still unknown but return type is clear
 *   const y = yield* $(List([3, 4]))
 *   return x + y
 * })
 * ```
 */
type DoGenerator<T, TYield = unknown> = Generator<TYield, T, unknown>;
/**
 * Extracts values from monads in Do-notation with type inference.
 * The '$' symbol is the universal extraction operator in functional programming.
 *
 * @example
 * ```typescript
 * const result = Do(function* () {
 *   const x = yield* $(Option(5))        // x: number
 *   const y = yield* $(List([1, 2, 3]))  // y: number (for cartesian product)
 *   const name = yield* $(Right("Alice")) // name: string
 *   return `${name}: ${x + y}`
 * })
 * ```
 *
 * @param monad - Any monad that can be unwrapped (Option, Either, List, Try, etc.)
 * @returns A generator that yields the monad and returns its extracted value
 */
declare function $<T>(monad: Option<T>): Generator<Option<T>, T, T>;
declare function $<L, R>(monad: Either<L, R>): Generator<Either<L, R>, R, R>;
declare function $<T>(monad: List<T>): Generator<List<T>, T, T>;
declare function $<T>(monad: Try<T>): Generator<Try<T>, T, T>;
declare function $<T>(monad: Doable<T>): Generator<Doable<T>, T, T>;
declare function $<M>(monad: M): Generator<M, InferYieldType<M>, InferYieldType<M>>;
type InferYieldType<M> = M extends {
  isSome(): boolean;
  get(): infer T;
} ? T : M extends {
  isRight(): boolean;
  value: infer R;
} ? R : M extends {
  toArray(): (infer T)[];
} ? T : M extends {
  isSuccess(): boolean;
  get(): infer T;
} ? T : M extends Doable<infer T> ? T : unknown;
declare const NoneError: (message?: string) => Error;
interface LeftErrorType<L> extends Error {
  value: L;
}
declare const LeftError: <L>(value: L, message?: string) => LeftErrorType<L>;
declare const EmptyListError: (message?: string) => Error;
interface FailureErrorType extends Error {
  cause: Error;
}
declare const FailureError: (cause: Error, message?: string) => FailureErrorType;
//#endregion
//#region src/error/ErrorFormatter.d.ts
/**
 * Type definition for task information that may be attached to errors
 */
type TaskErrorInfo = {
  name?: string;
  description?: string;
  [key: string]: unknown;
};
/**
 * Type definition for an error with potential task information
 */
type ErrorWithTaskInfo = Error & {
  taskInfo?: TaskErrorInfo;
  data?: unknown;
};
/**
 * Type definition for a structured error chain element
 */
type ErrorChainElement = {
  message?: string;
  name?: string;
  taskInfo?: TaskErrorInfo;
  stack?: string;
  [key: string]: unknown;
};
/**
 * Options for formatting error chains
 */
type ErrorFormatterOptions = {
  /** Include task names in the formatted output */
  includeTasks?: boolean;
  /** Include stack traces in the formatted output */
  includeStackTrace?: boolean;
  /** Separator between error lines (default: newline) */
  separator?: string;
  /** Include detailed error data in the output */
  includeData?: boolean;
  /** Maximum number of stack frames to include if stack trace is enabled */
  maxStackFrames?: number;
  /** Title to display at the start of the formatted error */
  title?: string;
  /** Format the output with colors for console display */
  colors?: boolean;
};
/**
 * Safely stringify data including BigInt values and circular references
 */
declare function safeStringify(obj: unknown): string;
/**
 * Format a stack trace string for better readability
 */
declare function formatStackTrace(stack: string | undefined): string;
/**
 * Create a formatted string representation of an error for better logging and display
 *
 * @example
 * ```typescript
 * const error = new Error("Something went wrong");
 * console.error(formatError(error, { colors: true, includeData: true }));
 * ```
 */
declare function formatError(error: unknown, options?: ErrorFormatterOptions): string;
/**
 * Create a serializer function for Pino or other JSON loggers
 * to better represent errors with their full context
 */
declare function createErrorSerializer(): (err: unknown) => unknown;
//#endregion
//#region src/error/typed/TypedError.d.ts
/**
 * Type-safe error codes using template literal types
 */
type ErrorCode = "VALIDATION_FAILED" | "NETWORK_ERROR" | "AUTH_REQUIRED" | "NOT_FOUND" | "PERMISSION_DENIED" | "RATE_LIMITED" | "INTERNAL_ERROR" | "BAD_REQUEST" | "CONFLICT" | "TIMEOUT";
/**
 * Template literal type for error messages based on error code
 */
type ErrorMessage<T extends ErrorCode> = T extends "VALIDATION_FAILED" ? `Validation failed: ${string}` : T extends "NETWORK_ERROR" ? `Network error: ${string}` : T extends "AUTH_REQUIRED" ? `Authentication required: ${string}` : T extends "NOT_FOUND" ? `Not found: ${string}` : T extends "PERMISSION_DENIED" ? `Permission denied: ${string}` : T extends "RATE_LIMITED" ? `Rate limit exceeded: ${string}` : T extends "INTERNAL_ERROR" ? `Internal server error: ${string}` : T extends "BAD_REQUEST" ? `Bad request: ${string}` : T extends "CONFLICT" ? `Conflict: ${string}` : T extends "TIMEOUT" ? `Request timeout: ${string}` : never;
/**
 * HTTP status codes mapped to error codes
 */
type ErrorStatus<T extends ErrorCode> = T extends "VALIDATION_FAILED" | "BAD_REQUEST" ? 400 : T extends "AUTH_REQUIRED" ? 401 : T extends "PERMISSION_DENIED" ? 403 : T extends "NOT_FOUND" ? 404 : T extends "CONFLICT" ? 409 : T extends "RATE_LIMITED" ? 429 : T extends "TIMEOUT" ? 408 : T extends "INTERNAL_ERROR" ? 500 : T extends "NETWORK_ERROR" ? 503 : 500;
/**
 * Context type for each error code
 */
type TypedErrorContext<T extends ErrorCode> = T extends "VALIDATION_FAILED" ? {
  field: string;
  value: unknown;
  rule: string;
} : T extends "NETWORK_ERROR" ? {
  url: string;
  method: string;
  statusCode?: number;
} : T extends "AUTH_REQUIRED" ? {
  resource: string;
  requiredRole?: string;
} : T extends "NOT_FOUND" ? {
  resource: string;
  id: string | number;
} : T extends "PERMISSION_DENIED" ? {
  action: string;
  resource: string;
  userId?: string;
} : T extends "RATE_LIMITED" ? {
  limit: number;
  window: string;
  retryAfter?: number;
} : T extends "INTERNAL_ERROR" ? {
  errorId: string;
  timestamp: string;
} : T extends "BAD_REQUEST" ? {
  reason: string;
  expected?: string;
} : T extends "CONFLICT" ? {
  resource: string;
  conflictingValue: string;
} : T extends "TIMEOUT" ? {
  duration: number;
  operation: string;
} : Record<string, unknown>;
/**
 * Type-safe error class with template literal types
 */
interface TypedError<T extends ErrorCode> extends Throwable {
  readonly code: T;
  readonly message: ErrorMessage<T>;
  readonly status: ErrorStatus<T>;
  readonly context: TypedErrorContext<T>;
  readonly timestamp: string;
  readonly traceId?: string;
}
declare const TypedError: (<T extends ErrorCode>(code: T, message: ErrorMessage<T>, context: TypedErrorContext<T>, options?: {
  cause?: unknown;
  traceId?: string;
}) => TypedError<T>) & {
  /**
   * Create a validation error
   * @example
   * const error = TypedError.validation("email", "test@", "must be valid email")
   * // Type: TypedError<"VALIDATION_FAILED">
   * // Message must match: "Validation failed: ..."
   */
  validation: (field: string, value: unknown, rule: string) => TypedError<"VALIDATION_FAILED">;
  /**
   * Create a network error
   * @example
   * const error = TypedError.network("https://api.example.com", "POST", 500)
   * // Type: TypedError<"NETWORK_ERROR">
   */
  network: (url: string, method: string, statusCode?: number) => TypedError<"NETWORK_ERROR">;
  /**
   * Create an authentication error
   * @example
   * const error = TypedError.auth("/api/admin", "admin")
   * // Type: TypedError<"AUTH_REQUIRED">
   */
  auth: (resource: string, requiredRole?: string) => TypedError<"AUTH_REQUIRED">;
  /**
   * Create a not found error
   * @example
   * const error = TypedError.notFound("user", "123")
   * // Type: TypedError<"NOT_FOUND">
   */
  notFound: (resource: string, id: string | number) => TypedError<"NOT_FOUND">;
  /**
   * Create a permission denied error
   * @example
   * const error = TypedError.permission("delete", "post", "user123")
   * // Type: TypedError<"PERMISSION_DENIED">
   */
  permission: (action: string, resource: string, userId?: string) => TypedError<"PERMISSION_DENIED">;
  /**
   * Create a rate limit error
   * @example
   * const error = TypedError.rateLimit(100, "1h", 3600)
   * // Type: TypedError<"RATE_LIMITED">
   */
  rateLimit: (limit: number, window: string, retryAfter?: number) => TypedError<"RATE_LIMITED">;
  /**
   * Create an internal error
   * @example
   * const error = TypedError.internal("ERR-500-ABC123")
   * // Type: TypedError<"INTERNAL_ERROR">
   */
  internal: (errorId: string) => TypedError<"INTERNAL_ERROR">;
  /**
   * Create a bad request error
   * @example
   * const error = TypedError.badRequest("Invalid JSON", "valid JSON object")
   * // Type: TypedError<"BAD_REQUEST">
   */
  badRequest: (reason: string, expected?: string) => TypedError<"BAD_REQUEST">;
  /**
   * Create a conflict error
   * @example
   * const error = TypedError.conflict("email", "user@example.com")
   * // Type: TypedError<"CONFLICT">
   */
  conflict: (resource: string, conflictingValue: string) => TypedError<"CONFLICT">;
  /**
   * Create a timeout error
   * @example
   * const error = TypedError.timeout(30000, "database query")
   * // Type: TypedError<"TIMEOUT">
   */
  timeout: (duration: number, operation: string) => TypedError<"TIMEOUT">;
  /**
   * Check if a value is a TypedError
   */
  isTypedError: (value: unknown) => value is TypedError<ErrorCode>;
  /**
   * Check if a TypedError has a specific code
   */
  hasCode: <T extends ErrorCode>(error: TypedError<ErrorCode>, code: T) => error is TypedError<T>;
};
//#endregion
//#region src/error/typed/Validation.d.ts
/**
 * Validation rule types using template literal types
 */
type ValidationRule = `min:${number}` | `max:${number}` | `minLength:${number}` | `maxLength:${number}` | `pattern:${string}` | `email` | `url` | `uuid` | `required` | `numeric` | `alpha` | `alphanumeric` | `date` | `future` | `past` | `in:${string}` | `notIn:${string}`;
/**
 * Validator function type
 */
type Validator<T> = (value: unknown) => Either<TypedError<"VALIDATION_FAILED">, T>;
/**
 * Field validation result
 */
type FieldValidation<T> = {
  field: string;
  value: unknown;
  result: Either<TypedError<"VALIDATION_FAILED">, T>;
};
/**
 * Form validation result
 */
type FormValidation<T extends Record<string, Type>> = Either<List<TypedError<"VALIDATION_FAILED">>, T>;
declare const Validation: (<T extends Type>(rule: ValidationRule) => Validator<T>) & {
  /**
   * Common pre-built validators
   */
  validators: {
    email: Validator<string>;
    url: Validator<string>;
    uuid: Validator<string>;
    required: Validator<string>;
    numeric: Validator<number>;
    positiveNumber: Validator<number>;
    nonEmptyString: Validator<string>;
  };
  /**
   * Create a validator from a rule string
   * @example
   * const validator = Validation.rule<number>("min:18")
   * const result = validator(25) // Right(25)
   * const error = validator(15) // Left(TypedError)
   */
  rule: <T extends Type>(rule: ValidationRule) => Validator<T>;
  /**
   * Combine multiple validators
   * @example
   * const validator = Validation.combine(
   *   Validation.rule<string>("required"),
   *   Validation.rule<string>("email"),
   *   Validation.rule<string>("maxLength:100")
   * )
   */
  combine: <T extends Type>(...validators: Validator<T>[]) => Validator<T>;
  /**
   * Create a custom validator
   * @example
   * const isEven = Validation.custom<number>(
   *   (value) => typeof value === "number" && value % 2 === 0,
   *   "must be an even number"
   * )
   */
  custom: <T extends Type>(predicate: (value: unknown) => boolean, errorMessage: string) => Validator<T>;
  /**
   * Validate a form with multiple fields
   * @example
   * const schema = {
   *   name: Validation.rule<string>("required"),
   *   email: Validation.rule<string>("email"),
   *   age: Validation.rule<number>("min:18")
   * }
   * const result = Validation.form(schema, { name: "John", email: "john@example.com", age: 25 })
   */
  form: <T extends Record<string, Type>>(schema: { [K in keyof T]: Validator<T[K]>; }, data: Record<string, unknown>) => FormValidation<T>;
};
//#endregion
//#region src/io/Tag.d.ts
/**
 * Tag module - service identifiers for dependency injection.
 * @module Tag
 * @category IO
 *
 * Tags are used to identify services in a type-safe way.
 * Each Tag has a unique identifier and carries the type of the service.
 */
/**
 * A Tag identifies a service type and provides a unique identifier.
 * Used for dependency injection with IO effects.
 *
 * @typeParam S - The service type this tag identifies
 *
 * @example
 * ```typescript
 * // Define service interfaces
 * interface UserService {
 *   getUser(id: string): IO<never, Error, User>
 * }
 *
 * // Create a tag for the service
 * const UserService = Tag<UserService>("UserService")
 *
 * // Use in effects
 * const getUser = (id: string) =>
 *   IO.service(UserService).flatMap(svc => svc.getUser(id))
 * ```
 */
interface Tag<S extends Type> {
  /**
   * Unique identifier for this tag
   */
  readonly id: string;
  /**
   * Phantom type to carry the service type
   * @internal
   */
  readonly _S?: S;
  /**
   * Type brand to distinguish tags
   * @internal
   */
  readonly _tag: "Tag";
  /**
   * String representation
   */
  toString(): string;
}
/**
 * Creates a Tag for identifying a service type.
 *
 * @param id - Unique identifier for this tag (usually the service name)
 * @returns A Tag that can be used to request the service
 *
 * @example
 * ```typescript
 * interface Logger {
 *   log(message: string): void
 * }
 *
 * const Logger = Tag<Logger>("Logger")
 *
 * // Now Logger can be used to request the Logger service
 * const program = IO.service(Logger).flatMap(logger =>
 *   IO.sync(() => logger.log("Hello!"))
 * )
 * ```
 */
declare const Tag: <S extends Type>(id: string) => Tag<S>;
/**
 * Type helper to extract the service type from a Tag
 */
type TagService<T> = T extends Tag<infer S> ? S : never;
//#endregion
//#region src/io/Context.d.ts
/**
 * Context module - service container for dependency injection.
 * @module Context
 * @category IO
 *
 * Context is an immutable container that holds service implementations
 * identified by their Tags.
 */
/**
 * Context holds service implementations for dependency injection.
 * It's an immutable container that maps Tags to their implementations.
 *
 * @typeParam R - The services contained in this context (intersection type)
 *
 * @example
 * ```typescript
 * const ctx = Context.empty()
 *   .add(Logger, consoleLogger)
 *   .add(Database, pgDatabase)
 *
 * // Access a service
 * const logger = ctx.get(Logger) // Option<Logger>
 * const loggerUnsafe = ctx.unsafeGet(Logger) // Logger (throws if missing)
 * ```
 */
interface Context<R extends Type> {
  /**
   * Type brand
   * @internal
   */
  readonly _tag: "Context";
  /**
   * Phantom type for requirements
   * @internal
   */
  readonly _R?: R;
  /**
   * Internal service map
   * @internal
   */
  readonly services: ReadonlyMap<string, Type>;
  /**
   * Gets a service from the context.
   * @param tag - The tag identifying the service
   * @returns Some(service) if found, None otherwise
   */
  get<S extends Type>(tag: Tag<S>): Option<S>;
  /**
   * Gets a service from the context, throwing if not found.
   * @param tag - The tag identifying the service
   * @returns The service
   * @throws Error if service not found
   */
  unsafeGet<S extends Type>(tag: Tag<S>): S;
  /**
   * Checks if a service exists in the context.
   * @param tag - The tag to check
   * @returns true if the service exists
   */
  has<S extends Type>(tag: Tag<S>): boolean;
  /**
   * Adds a service to the context, returning a new context.
   * @param tag - The tag for the service
   * @param service - The service implementation
   * @returns A new context with the service added
   */
  add<S extends Type>(tag: Tag<S>, service: S): Context<R & S>;
  /**
   * Merges another context into this one.
   * @param other - The context to merge
   * @returns A new context with all services from both
   */
  merge<R2 extends Type>(other: Context<R2>): Context<R & R2>;
  /**
   * Returns the number of services in this context.
   */
  readonly size: number;
  /**
   * String representation
   */
  toString(): string;
}
/**
 * Context companion object with utility methods
 */
declare const Context: {
  /**
   * Creates an empty context with no services.
   */
  empty: <R extends Type = never>() => Context<R>;
  /**
   * Creates a context with a single service.
   * @param tag - The tag for the service
   * @param service - The service implementation
   */
  make: <S extends Type>(tag: Tag<S>, service: S) => Context<S>;
  /**
   * Checks if a value is a Context.
   */
  isContext: <R extends Type>(value: unknown) => value is Context<R>;
};
/**
 * Type helper to extract requirements from a Context
 */
type ContextServices<C> = C extends Context<infer R> ? R : never;
/**
 * Type helper to check if a context provides a service
 */
type HasService<C, S> = S extends ContextServices<C> ? true : false;
//#endregion
//#region src/io/Exit.d.ts
/**
 * Exit type module - represents the outcome of running an IO effect.
 * @module Exit
 * @category IO
 */
/**
 * Possible outcome types for an Exit
 */
type ExitTag = "Success" | "Failure" | "Interrupted";
/**
 * Exit represents the outcome of running an IO effect.
 * - Success: The effect completed successfully with a value
 * - Failure: The effect failed with a typed error
 * - Interrupted: The effect was cancelled/interrupted
 */
interface Exit<E extends Type, A extends Type> {
  readonly [Symbol.toStringTag]: string;
  readonly _tag: ExitTag;
  /**
   * Type guard to check if this is a Success
   */
  isSuccess(): this is Exit<E, A> & {
    readonly _tag: "Success";
    value: A;
  };
  /**
   * Type guard to check if this is a Failure
   */
  isFailure(): this is Exit<E, A> & {
    readonly _tag: "Failure";
    error: E;
  };
  /**
   * Type guard to check if this is Interrupted
   */
  isInterrupted(): this is Exit<E, A> & {
    readonly _tag: "Interrupted";
    fiberId: string;
  };
  /**
   * Maps the success value
   */
  map<B extends Type>(f: (a: A) => B): Exit<E, B>;
  /**
   * Maps the error value
   */
  mapError<E2 extends Type>(f: (e: E) => E2): Exit<E2, A>;
  /**
   * Maps both error and success values
   */
  mapBoth<E2 extends Type, B extends Type>(onError: (e: E) => E2, onSuccess: (a: A) => B): Exit<E2, B>;
  /**
   * Flat maps the success value
   */
  flatMap<B extends Type>(f: (a: A) => Exit<E, B>): Exit<E, B>;
  /**
   * Pattern matches over the Exit
   */
  fold<T>(onFailure: (e: E) => T, onSuccess: (a: A) => T, onInterrupted?: (fiberId: string) => T): T;
  /**
   * Pattern matches over the Exit with object patterns
   */
  match<T>(patterns: {
    Success: (value: A) => T;
    Failure: (error: E) => T;
    Interrupted: (fiberId: string) => T;
  }): T;
  /**
   * Returns the success value or throws
   */
  orThrow(): A;
  /**
   * Returns the success value or a default
   */
  orElse(defaultValue: A): A;
  /**
   * Converts to Option (Some for Success, None otherwise)
   */
  toOption(): Option<A>;
  /**
   * Converts to Either (Right for Success, Left for Failure)
   * Throws if Interrupted
   */
  toEither(): Either<E, A>;
  /**
   * Returns the raw value for inspection
   */
  toValue(): {
    _tag: ExitTag;
    value?: A;
    error?: E;
    fiberId?: string;
  };
  /**
   * String representation
   */
  toString(): string;
  /**
   * JSON serialization
   */
  toJSON(): {
    _tag: ExitTag;
    value?: A;
    error?: E;
    fiberId?: string;
  };
}
/**
 * Exit type for representing effect outcomes.
 *
 * @example
 * ```typescript
 * const success = Exit.succeed(42)
 * const failure = Exit.fail(new Error("oops"))
 * const interrupted = Exit.interrupt("fiber-123")
 *
 * success.fold(
 *   (err) => console.error(err),
 *   (value) => console.log(value),
 *   (fiberId) => console.log("interrupted:", fiberId)
 * )
 * ```
 */
declare const Exit: (<E extends Type, A extends Type>(value: A) => Exit<E, A>) & {
  /**
   * Creates a Success Exit
   */
  succeed: <E extends Type, A extends Type>(value: A) => Exit<E, A>;
  /**
   * Creates a Failure Exit
   */
  fail: <E extends Type, A extends Type>(error: E) => Exit<E, A>;
  /**
   * Creates an Interrupted Exit with a fiber ID
   */
  interrupt: <E extends Type, A extends Type>(fiberId: string) => Exit<E, A>;
  /**
   * Creates an Interrupted Exit with a default fiber ID
   */
  interrupted: <E extends Type, A extends Type>() => Exit<E, A>;
  /**
   * Type guard for Success
   */
  isSuccess: <E extends Type, A extends Type>(exit: Exit<E, A>) => exit is Exit<E, A> & {
    readonly _tag: "Success";
    value: A;
  };
  /**
   * Type guard for Failure
   */
  isFailure: <E extends Type, A extends Type>(exit: Exit<E, A>) => exit is Exit<E, A> & {
    readonly _tag: "Failure";
    error: E;
  };
  /**
   * Type guard for Interrupted
   */
  isInterrupted: <E extends Type, A extends Type>(exit: Exit<E, A>) => exit is Exit<E, A> & {
    readonly _tag: "Interrupted";
    fiberId: string;
  };
  /**
   * Creates an Exit from an Either
   */
  fromEither: <E extends Type, A extends Type>(either: Either<E, A>) => Exit<E, A>;
  /**
   * Creates an Exit from an Option
   */
  fromOption: <A extends Type>(option: Option<A>, onNone: () => unknown) => Exit<unknown, A>;
  /**
   * Combines two Exits, keeping the first failure or combining successes
   */
  zip: <E extends Type, A extends Type, B extends Type>(exitA: Exit<E, A>, exitB: Exit<E, B>) => Exit<E, readonly [A, B]>;
  /**
   * Collects all Exits into an Exit of array
   */
  all: <E extends Type, A extends Type>(exits: readonly Exit<E, A>[]) => Exit<E, readonly A[]>;
};
//#endregion
//#region src/io/Layer.d.ts
/**
 * Layer module - service construction recipes.
 * @module Layer
 * @category IO
 *
 * Layers describe how to construct services, including their dependencies.
 * They can be composed to build complex service graphs.
 */
/**
 * A Layer describes how to build a service or set of services.
 *
 * @typeParam RIn - Required services (dependencies)
 * @typeParam E - Possible errors during construction
 * @typeParam ROut - Services provided by this layer
 *
 * @example
 * ```typescript
 * // A layer that provides a Logger service
 * const LoggerLive = Layer.succeed(Logger, consoleLogger)
 *
 * // A layer that requires Config and provides Database
 * const DatabaseLive = Layer.fromFunction(Database, (config: Config) =>
 *   createDatabase(config.connectionString)
 * )
 * ```
 */
interface Layer<RIn extends Type, E extends Type, ROut extends Type> {
  /**
   * Type brand
   * @internal
   */
  readonly _tag: "Layer";
  /**
   * Phantom types
   * @internal
   */
  readonly _RIn?: RIn;
  readonly _E?: E;
  readonly _ROut?: ROut;
  /**
   * The build function that creates the context
   * @internal
   */
  readonly build: (input: Context<RIn>) => Promise<Context<ROut>>;
  /**
   * Composes this layer with another, running them in sequence.
   * The output of this layer becomes available to the next layer.
   * @param that - Layer to compose with
   */
  provideToAndMerge<RIn2 extends Type, E2 extends Type, ROut2 extends Type>(that: Layer<RIn2 | ROut, E2, ROut2>): Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut | ROut2>;
  /**
   * Merges two independent layers.
   * @param that - Layer to merge with
   */
  merge<RIn2 extends Type, E2 extends Type, ROut2 extends Type>(that: Layer<RIn2, E2, ROut2>): Layer<RIn | RIn2, E | E2, ROut | ROut2>;
  /**
   * Maps the output of this layer.
   * @param f - Function to transform the output
   */
  map<ROut2 extends Type>(f: (ctx: Context<ROut>) => Context<ROut2>): Layer<RIn, E, ROut2>;
  /**
   * String representation
   */
  toString(): string;
}
/**
 * Layer companion object with construction methods
 */
declare const Layer: {
  /**
   * Creates a layer that provides a service with a constant value.
   * @param tag - The service tag
   * @param service - The service implementation
   */
  succeed: <S extends Type>(tag: Tag<S>, service: S) => Layer<never, never, S>;
  /**
   * Creates a layer from an async function.
   * @param tag - The service tag
   * @param f - Async function to create the service
   */
  effect: <S extends Type, E extends Type>(tag: Tag<S>, f: () => Promise<S>) => Layer<never, E, S>;
  /**
   * Creates a layer from a sync function.
   * @param tag - The service tag
   * @param f - Function to create the service
   */
  sync: <S extends Type>(tag: Tag<S>, f: () => S) => Layer<never, never, S>;
  /**
   * Creates a layer that depends on another service.
   * @param tag - The service tag to provide
   * @param depTag - The dependency tag
   * @param f - Function to create the service from the dependency
   */
  fromService: <Dep extends Type, S extends Type>(tag: Tag<S>, depTag: Tag<Dep>, f: (dep: Dep) => S) => Layer<Dep, never, S>;
  /**
   * Creates a layer that depends on another service (async).
   * @param tag - The service tag to provide
   * @param depTag - The dependency tag
   * @param f - Async function to create the service from the dependency
   */
  fromServiceEffect: <Dep extends Type, E extends Type, S extends Type>(tag: Tag<S>, depTag: Tag<Dep>, f: (dep: Dep) => Promise<S>) => Layer<Dep, E, S>;
  /**
   * Creates a layer from a context.
   * @param context - The context to use
   */
  fromContext: <R extends Type>(context: Context<R>) => Layer<never, never, R>;
  /**
   * Creates an empty layer that provides nothing.
   */
  empty: () => Layer<never, never, never>;
  /**
   * Merges multiple layers into one.
   * @param layers - Layers to merge
   */
  mergeAll: <Layers extends Layer<Type, Type, Type>[]>(...layers: Layers) => Layer<Layers[number] extends Layer<infer RIn, Type, Type> ? RIn : never, Layers[number] extends Layer<Type, infer E, Type> ? E : never, Layers[number] extends Layer<Type, Type, infer ROut> ? ROut : never>;
};
/**
 * Type helper to extract input requirements from a Layer
 */
type LayerInput<L> = L extends Layer<infer RIn, Type, Type> ? RIn : never;
/**
 * Type helper to extract error type from a Layer
 */
type LayerError<L> = L extends Layer<Type, infer E, Type> ? E : never;
/**
 * Type helper to extract output services from a Layer
 */
type LayerOutput<L> = L extends Layer<Type, Type, infer ROut> ? ROut : never;
//#endregion
//#region src/io/IO.d.ts
/**
 * Error thrown when an effect times out.
 */
declare class TimeoutError extends Error {
  readonly duration: number;
  readonly _tag: "TimeoutError";
  constructor(duration: number, message?: string);
}
/**
 * Error thrown when an effect is interrupted.
 */
declare class InterruptedError extends Error {
  readonly _tag: "InterruptedError";
  constructor(message?: string);
}
/**
 * Error thrown when a combinator that cannot run on the synchronous interpreter is
 * reached by `runSync`. `timeout` and `race` are inherently asynchronous — there is no
 * sync semantics for "wait `ms` then give up", or for racing concurrent effects.
 *
 * This is a **programmer error, not a domain failure**: it says the effect was built
 * wrong for the terminal it was run with, so recovery combinators deliberately do not
 * catch it (see {@link rethrowIfNonRecoverable}). Before it had its own type it was a
 * plain `Error`, indistinguishable from a failed effect, so any downstream `.recover()`
 * absorbed it and silently produced the fallback — `IO.succeed(1).timeoutTo(50, 99)`
 * returned `Right(99)` under `runSync()`. See #246.
 */
declare class UnsupportedSyncOperationError extends Error {
  readonly operation: "timeout" | "race";
  readonly _tag: "UnsupportedSyncOperationError";
  constructor(operation: "timeout" | "race");
}
/**
 * Error surfaced by value-driven repeat combinators when the iteration bound is
 * reached without the predicate being satisfied. Carries the last observed
 * value so callers can report what the loop settled on.
 *
 * Type parameter `A` is the value type the loop was producing (or the state
 * type for `IO.iterate`).
 *
 * ## Narrowing when `E` is `unknown`
 *
 * If the step effect has `E = unknown` (common when lifting a Promise via
 * `IO(() => ...)` or `IO.async(...)` — see the JSDoc on those constructors),
 * TypeScript's union algebra collapses `unknown | RepeatExhausted<A>` back to
 * `unknown`, and `RepeatExhausted<A>` is lost from the surface type. The
 * runtime behavior is still correct (the `RepeatExhausted` instance is in the
 * `Left` at runtime — see reporter's JSON in issue #221) — but consumers need
 * a narrowing step to recover it. Use `RepeatExhausted.is`:
 *
 * @example
 * ```ts
 * const res = await IO.iterate(seed, step, done, { max: 20 }).run()
 * res.fold(
 *   (e) => {
 *     if (RepeatExhausted.is<StepState>(e)) {
 *       // e is now RepeatExhausted<StepState>; e.lastValue is StepState
 *       return e.lastValue
 *     }
 *     // e is still the collapsed E channel — handle as the caller sees fit
 *     throw e as Error
 *   },
 *   (settled) => settled,
 * )
 * ```
 *
 * The alternative — annotating `step`'s error channel so `E` is a concrete
 * tagged type — also works and preserves `RepeatExhausted<A>` in the union:
 *
 * @example
 * ```ts
 * const step = (s: S): IO<never, never, S> =>
 *   IO(() => runOnce(s)).mapError((_e) => _e as never)
 * // iterate result E channel: never | RepeatExhausted<S> === RepeatExhausted<S>
 * ```
 */
declare class RepeatExhausted<A = unknown> extends Error {
  readonly max: number;
  readonly lastValue?: A | undefined;
  readonly _tag: "RepeatExhausted";
  constructor(max: number, lastValue?: A | undefined, message?: string);
  /**
   * Runtime type guard. Narrows an `unknown` (or wider) value to
   * `RepeatExhausted<A>` when the tag matches. Use this to recover typed
   * exhaustion when the `E` channel has collapsed to `unknown` — a common
   * situation when the step effect is lifted from a Promise via `IO(...)` or
   * `IO.async(...)`. See the class-level JSDoc for a full example.
   *
   * The type parameter `A` is an unchecked assertion — the guard confirms the
   * shape is a `RepeatExhausted`, but cannot verify `lastValue` matches `A` at
   * runtime. Callers pass the state/value type they expect the loop to have
   * been producing.
   */
  static is<A = unknown>(e: unknown): e is RepeatExhausted<A>;
}
/**
 * IO Effect type module - a lazy, composable effect type with typed errors.
 * @module IO
 * @category IO
 *
 * IO<R, E, A> represents an effectful computation that:
 * - Requires environment R to run
 * - May fail with error E
 * - Produces value A on success
 *
 * Key features:
 * - Lazy execution (nothing runs until explicitly executed)
 * - Unified sync/async API
 * - Typed errors at compile time
 * - Composable via map/flatMap
 */
/**
 * Unique symbol for the internal effect representation.
 * Using a symbol key makes IO structurally opaque — TypeScript won't
 * deeply compare IOEffect types when checking IO assignability.
 * This allows IO<never, never, void> to be assignable to IO<any, any, any>
 * (needed for IO.gen) without deep variance failures on the effect ADT.
 * @internal
 */
declare const IOEffectKey: unique symbol;
type IOEffectKey = typeof IOEffectKey;
/**
 * Internal effect representation types
 */
type IOEffect<R, E, A> = {
  readonly _tag: "Sync";
  readonly thunk: () => A;
} | {
  readonly _tag: "Async";
  readonly thunk: () => Promise<A>;
} | {
  readonly _tag: "Auto";
  readonly thunk: () => A | Promise<A>;
} | {
  readonly _tag: "Succeed";
  readonly value: A;
} | {
  readonly _tag: "Fail";
  readonly error: E;
} | {
  readonly _tag: "Die";
  readonly defect: unknown;
} | {
  readonly _tag: "Interrupt";
} | {
  readonly _tag: "FlatMap";
  readonly effect: IO<R, E, unknown>;
  readonly f: (a: unknown) => IO<R, E, A>;
} | {
  readonly _tag: "Map";
  readonly effect: IO<R, E, unknown>;
  readonly f: (a: unknown) => A;
} | {
  readonly _tag: "MapError";
  readonly effect: IO<R, unknown, A>;
  readonly f: (e: unknown) => E;
} | {
  readonly _tag: "Recover";
  readonly effect: IO<R, E, A>;
  readonly fallback: A;
} | {
  readonly _tag: "RecoverWith";
  readonly effect: IO<R, unknown, unknown>;
  readonly f: (e: unknown) => IO<R, E, A>;
} | {
  readonly _tag: "Fold";
  readonly effect: IO<R, unknown, unknown>;
  readonly onFailure: (e: unknown) => A;
  readonly onSuccess: (a: unknown) => A;
} | {
  readonly _tag: "Bracket";
  readonly acquire: IO<R, E, unknown>;
  readonly use: (a: unknown) => IO<R, E, A>;
  readonly release: (a: unknown) => IO<R, never, void>;
} | {
  readonly _tag: "BracketExit";
  readonly acquire: IO<R, E, unknown>;
  readonly use: (a: unknown) => IO<R, E, A>;
  readonly release: (a: unknown, exit: Exit<unknown, unknown>) => IO<R, never, void>;
} | {
  readonly _tag: "Race";
  readonly effects: readonly IO<R, E, A>[];
} | {
  readonly _tag: "Timeout";
  readonly effect: IO<R, E, A>;
  readonly duration: number;
} | {
  readonly _tag: "Service";
  readonly tag: Tag<A>;
} | {
  readonly _tag: "ProvideContext";
  readonly effect: IO<R, E, A>;
  readonly context: Context<R>;
};
/**
 * IO<R, E, A> represents a lazy, composable effect.
 *
 * @typeParam R - Requirements (environment/dependencies needed to run)
 * @typeParam E - Error type (typed failures)
 * @typeParam A - Success type (value produced on success)
 */
/**
 * Minimal marker interface for IO-like values that can be yielded in IO.gen.
 * Using this instead of IO<any, any, any> avoids deep structural variance
 * failures when yielding IO<never, never, void> in generators.
 * @internal
 */
interface IOYieldable {
  readonly [Symbol.toStringTag]: string;
}
interface IO<in out R extends Type, out E extends Type, out A extends Type> {
  readonly [Symbol.toStringTag]: string;
  /**
   * Internal effect representation (symbol-keyed for opacity)
   * @internal
   */
  readonly [IOEffectKey]: IOEffect<R, E, A>;
  /**
   * Transforms the success value.
   * @param f - Function to apply to the success value
   * @returns New IO with transformed value
   */
  map<B extends Type>(f: (a: A) => B): IO<R, E, B>;
  /**
   * Chains another IO effect based on the success value.
   * @param f - Function returning next IO effect
   * @returns New IO with combined effects
   */
  flatMap<R2 extends Type, E2 extends Type, B extends Type>(f: (a: A) => IO<R2, E2, B>): IO<R | R2, E | E2, B>;
  /**
   * Applies a side effect without changing the value.
   * @param f - Side effect function
   * @returns Same IO for chaining
   */
  tap(f: (a: A) => void): IO<R, E, A>;
  /**
   * Applies an effectful side effect without changing the value.
   * @param f - Function returning IO for side effect
   * @returns Same value after running side effect
   */
  tapEffect<R2 extends Type, E2 extends Type, B extends Type>(f: (a: A) => IO<R2, E2, B>): IO<R | R2, E | E2, A>;
  /**
   * Transforms the error value.
   * @param f - Function to apply to the error
   * @returns New IO with transformed error
   */
  mapError<E2 extends Type>(f: (e: E) => E2): IO<R, E2, A>;
  /**
   * Executes a side effect on the error without changing it.
   * Useful for logging errors while preserving the error chain.
   *
   * @param f - Side effect function to run on error
   * @returns Same IO with the side effect attached
   *
   * @example
   * ```typescript
   * const io = IO.asyncResult(() => query(), toError)
   *   .tapError(err => console.error('Query failed:', err))
   *   .map(data => transform(data))
   * ```
   */
  tapError(f: (e: E) => void): IO<R, E, A>;
  /**
   * Recovers from any error with a fallback value.
   * @param fallback - Value to use on error
   * @returns New IO that never fails
   */
  recover<B extends Type>(fallback: B): IO<R, never, A | B>;
  /**
   * Recovers from error by running another effect.
   * @param f - Function returning recovery effect
   * @returns New IO with error handling
   */
  recoverWith<R2 extends Type, E2 extends Type, B extends Type>(f: (e: E) => IO<R2, E2, B>): IO<R | R2, E2, A | B>;
  /**
   * Pattern matches on success and failure.
   * @param onFailure - Handler for failures
   * @param onSuccess - Handler for successes
   * @returns New IO with handled result
   */
  fold<B extends Type>(onFailure: (e: E) => B, onSuccess: (a: A) => B): IO<R, never, B>;
  /**
   * Pattern matches with object pattern syntax.
   */
  match<B extends Type>(patterns: {
    failure: (e: E) => B;
    success: (a: A) => B;
  }): IO<R, never, B>;
  /**
   * Catches errors with a specific tag and handles them.
   * @param tag - The error tag to catch
   * @param handler - Handler for the caught error
   */
  catchTag<K extends (E extends {
    _tag: string;
  } ? E["_tag"] : never), R2 extends Type, E2 extends Type, B extends Type>(tag: K, handler: (e: Extract<E, {
    _tag: K;
  }>) => IO<R2, E2, B>): IO<R | R2, Exclude<E, {
    _tag: K;
  }> | E2, A | B>;
  /**
   * Catches all errors (alias for recoverWith).
   */
  catchAll<R2 extends Type, E2 extends Type, B extends Type>(handler: (e: E) => IO<R2, E2, B>): IO<R | R2, E2, A | B>;
  /**
   * Retries the effect up to n times on failure.
   * @param n - Maximum number of retries
   */
  retry(n: number): IO<R, E, A>;
  /**
   * Retries the effect with a delay between attempts.
   * @param n - Maximum number of retries
   * @param delayMs - Delay between retries in milliseconds
   */
  retryWithDelay(n: number, delayMs: number): IO<R, E, A>;
  /**
   * Retries the effect only while a predicate over the error holds.
   *
   * Useful for selective retry policies — e.g. retry HTTP 5xx but not 4xx,
   * retry network errors but not validation errors. The predicate is evaluated
   * BEFORE each retry; returning `false` short-circuits and re-fails with the
   * original error.
   *
   * @param opts.n - Maximum number of retry attempts.
   * @param opts.while - Predicate `(error, attempt) => boolean` (attempt is 1-indexed
   *   for the first retry; if the predicate returns false, the retry is skipped).
   * @param opts.delayMs - Optional fixed delay between attempts.
   *
   * @example
   * ```ts
   * Http.get("/api/users", { decode })
   *   .retryWhile({
   *     n: 3,
   *     while: (e) => e._tag === "HttpStatusError" && e.status >= 500,
   *     delayMs: 250,
   *   })
   * ```
   */
  retryWhile(opts: {
    readonly n: number;
    readonly while: (error: E, attempt: number) => boolean;
    readonly delayMs?: number;
  }): IO<R, E, A>;
  /**
   * Retries the effect with exponential backoff and optional full jitter.
   *
   * Delay schedule: `min(maxMs, baseMs * factor^(attempt-1))`. With jitter
   * enabled, the actual delay is `computed * (0.5 + Math.random() * 0.5)`
   * (full jitter, 50–100% of the computed value) — prevents thundering herd.
   *
   * @param opts.n - Maximum number of retry attempts.
   * @param opts.baseMs - Initial delay before the first retry.
   * @param opts.maxMs - Cap on per-attempt delay. Defaults to 30_000.
   * @param opts.factor - Backoff multiplier per attempt. Defaults to 2.
   * @param opts.jitter - Apply full jitter (50–100% of computed delay). Defaults to true.
   * @param opts.while - Optional predicate `(error, attempt) => boolean` gating each retry.
   *
   * @example
   * ```ts
   * const isRetryable = (e: HttpError): boolean =>
   *   e._tag === "NetworkError" ||
   *   (e._tag === "HttpStatusError" && (e.status >= 500 || e.status === 429))
   *
   * Http.get("/api/users", { decode })
   *   .retryWithBackoff({ n: 3, baseMs: 250, while: isRetryable })
   *   .timeout(10_000)
   * ```
   */
  retryWithBackoff(opts: {
    readonly n: number;
    readonly baseMs: number;
    readonly maxMs?: number;
    readonly factor?: number;
    readonly jitter?: boolean;
    readonly while?: (error: E, attempt: number) => boolean;
  }): IO<R, E, A>;
  /**
   * Re-runs the effect until its output satisfies `done`, or the `max` bound is hit.
   *
   * Value-channel dual of `retryWhile`: this repeats on success values that
   * haven't yet met the predicate, whereas the retry* family repeats on failure.
   * The first failure short-circuits and propagates unchanged. Compose the two
   * axes when both matter:
   *
   * @example
   * ```ts
   * pollJob
   *   .retry(3)                                                  // error axis
   *   .repeatUntil((job) => job.done, { max: 20, delayMs: 500 }) // value axis
   * ```
   *
   * @param done - Pure sync predicate. Loop stops (successfully) when this returns true.
   * @param opts.max - Maximum iterations before exhaustion is signaled.
   * @param opts.delayMs - Optional fixed delay between iterations.
   * @returns The satisfying value, or `RepeatExhausted<A>` in the error channel
   *   (carrying the last observed value) if the bound is reached first.
   */
  repeatUntil(done: (a: A) => boolean, opts: {
    readonly max: number;
    readonly delayMs?: number;
  }): IO<R, E | RepeatExhausted<A>, A>;
  /**
   * Re-runs the effect while `cont` holds, or until the `max` bound is hit.
   *
   * Symmetric sibling of `repeatUntil` — mirrors the naming of `retryWhile`.
   * `repeatWhile(cont)` is equivalent to `repeatUntil((a) => !cont(a))`; the
   * loop stops successfully as soon as `cont` returns false.
   *
   * @param cont - Pure sync predicate. Loop continues while this returns true.
   * @param opts.max - Maximum iterations before exhaustion is signaled.
   * @param opts.delayMs - Optional fixed delay between iterations.
   */
  repeatWhile(cont: (a: A) => boolean, opts: {
    readonly max: number;
    readonly delayMs?: number;
  }): IO<R, E | RepeatExhausted<A>, A>;
  /**
   * Sequences two IOs, keeping the second value.
   */
  zipRight<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | R2, E | E2, B>;
  /**
   * Sequences two IOs, keeping the first value.
   */
  zipLeft<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | R2, E | E2, A>;
  /**
   * Zips two IOs into a tuple.
   */
  zip<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | R2, E | E2, readonly [A, B]>;
  /**
   * Flattens a nested IO.
   */
  flatten<R2 extends Type, E2 extends Type, B extends Type>(this: IO<R, E, IO<R2, E2, B>>): IO<R | R2, E | E2, B>;
  /**
   * Provides a context to satisfy the requirements of this effect.
   * @param context - The context containing required services
   */
  provideContext<R2 extends R>(context: Context<R2>): IO<Exclude<R, R2>, E, A>;
  /**
   * Provides a single service to satisfy part of the requirements.
   * @param tag - The service tag
   * @param service - The service implementation
   */
  provideService<S extends Type>(tag: Tag<S>, service: S): IO<Exclude<R, S>, E, A>;
  /**
   * Provides services using a layer.
   * @param layer - The layer that provides services
   */
  provideLayer<RIn extends Type, E2 extends Type, ROut extends R>(layer: Layer<RIn, E2, ROut>): IO<RIn | Exclude<R, ROut>, E | E2, A>;
  /**
   * Runs the effect and returns an Either. Never throws.
   * This is the safe default - all errors become Left.
   * Requires R = never.
   */
  run(this: IO<never, E, A>): Promise<Either<E, A>>;
  /**
   * Runs the effect and returns a Promise of the value.
   * Throws on any error (typed E, defect, or interrupt).
   * Requires R = never.
   */
  runOrThrow(this: IO<never, E, A>): Promise<A>;
  /**
   * Runs a sync effect and returns an Either. Never throws.
   * This is the safe default - all errors become Left.
   * Throws only if the effect is async (cannot be made safe synchronously).
   * Requires R = never.
   */
  runSync(this: IO<never, E, A>): Either<E, A>;
  /**
   * Runs a sync effect and returns the value.
   * Throws on any error or if the effect is async.
   * Requires R = never.
   */
  runSyncOrThrow(this: IO<never, E, A>): A;
  /**
   * Runs the effect and returns an Exit.
   */
  runExit(this: IO<never, E, A>): Promise<Exit<E, A>>;
  /**
   * Runs the effect and returns an Option.
   * Some(value) on success, None on failure.
   */
  runOption(this: IO<never, E, A>): Promise<Option<A>>;
  /**
   * Runs the effect and returns a Try.
   * Success(value) on success, Failure(error) on failure.
   */
  runTry(this: IO<never, E, A>): Promise<ReturnType<typeof Try<A>>>;
  /**
   * Pipes the IO through a function.
   */
  pipe<B>(f: (self: IO<R, E, A>) => B): B;
  /**
   * Delays execution by the specified milliseconds.
   */
  delay(ms: number): IO<R, E, A>;
  /**
   * Fails with TimeoutError if the effect doesn't complete within the specified duration.
   * @param ms - Maximum time in milliseconds
   */
  timeout(ms: number): IO<R, E | TimeoutError, A>;
  /**
   * Returns a fallback value if the effect doesn't complete within the specified duration.
   * @param ms - Maximum time in milliseconds
   * @param fallback - Value to return on timeout
   */
  timeoutTo<B extends Type>(ms: number, fallback: B): IO<R, E, A | B>;
  /**
   * Converts to string representation.
   */
  toString(): string;
  /**
   * Converts to JSON representation.
   */
  toJSON(): {
    _tag: string;
    effect: unknown;
  };
  /**
   * Makes IO iterable for generator do-notation (yield* syntax).
   * Yields the IO itself, allowing IO.gen to extract the value.
   */
  [Symbol.iterator](): Generator<IO<R, E, A>, A, unknown>;
}
/**
 * Do-builder interface for chaining binds and maps
 */
interface DoBuilder<R extends Type, E extends Type, Ctx extends Record<string, Type>> {
  /**
   * The underlying IO effect
   */
  readonly effect: IO<R, E, Ctx>;
  /**
   * Binds the result of an effect to a named property in the context.
   * @param name - The property name to bind to
   * @param f - Function that returns an IO effect (receives current context)
   */
  bind<N extends string, R2 extends Type, E2 extends Type, A extends Type>(name: Exclude<N, keyof Ctx>, f: (ctx: Ctx) => IO<R2, E2, A>): DoBuilder<R | R2, E | E2, Ctx & Record<N, A>>;
  /**
   * Binds a pure value to a named property in the context.
   * @param name - The property name to bind to
   * @param f - Function that returns a value (receives current context)
   */
  let<N extends string, A extends Type>(name: Exclude<N, keyof Ctx>, f: (ctx: Ctx) => A): DoBuilder<R, E, Ctx & Record<N, A>>;
  /**
   * Transforms the final context value.
   * @param f - Function to transform the context
   */
  map<B extends Type>(f: (ctx: Ctx) => B): IO<R, E, B>;
  /**
   * Chains to another IO based on the context.
   * @param f - Function that returns an IO effect
   */
  flatMap<R2 extends Type, E2 extends Type, B extends Type>(f: (ctx: Ctx) => IO<R2, E2, B>): IO<R | R2, E | E2, B>;
  /**
   * Executes a side effect without changing the context.
   * @param f - Side effect function
   */
  tap(f: (ctx: Ctx) => void): DoBuilder<R, E, Ctx>;
  /**
   * Executes an effectful side effect without changing the context.
   * @param f - Function returning an IO for the side effect
   */
  tapEffect<R2 extends Type, E2 extends Type, B extends Type>(f: (ctx: Ctx) => IO<R2, E2, B>): DoBuilder<R | R2, E | E2, Ctx>;
  /**
   * Returns the final context as is.
   */
  done(): IO<R, E, Ctx>;
}
/**
 * IO effect type for lazy, composable effects with typed errors.
 *
 * @example
 * ```typescript
 * // Basic usage
 * const program = IO.sync(() => 42)
 *   .map(x => x * 2)
 *   .flatMap(x => IO.succeed(x + 1))
 *
 * const result = await program.run() // 85
 *
 * // Error handling
 * const safe = IO.tryPromise({
 *   try: () => fetch('/api/data'),
 *   catch: (e) => new NetworkError(e)
 * })
 *   .map(res => res.json())
 *   .recover({ fallback: 'default' })
 *
 * // Composition
 * const composed = IO.all([
 *   IO.succeed(1),
 *   IO.succeed(2),
 *   IO.succeed(3)
 * ]) // IO<never, never, [1, 2, 3]>
 * ```
 */
declare const IO: (<A extends Type>(f: () => A | Promise<A>) => IO<never, unknown, A>) & {
  /**
   * Creates an IO from a synchronous thunk.
   * The function is not executed until the IO is run.
   */
  sync: <A extends Type>(f: () => A) => IO<never, never, A>;
  /**
   * Creates an IO that succeeds with the given value.
   */
  succeed: <A extends Type>(value: A) => IO<never, never, A>;
  /**
   * Creates an IO that fails with the given error.
   */
  fail: <E extends Type>(error: E) => IO<never, E, never>;
  /**
   * Creates an IO that dies with an unrecoverable defect.
   */
  die: (defect: unknown) => IO<never, never, never>;
  /**
   * Creates an IO from an async thunk.
   * The Promise is not created until the IO is run.
   */
  async: <A extends Type>(f: () => Promise<A>) => IO<never, unknown, A>;
  /**
   * Creates an IO from a Promise with error handling.
   */
  tryPromise: <A extends Type, E extends Type>(opts: {
    readonly try: () => Promise<A>;
    readonly catch: (error: unknown) => E;
  }) => IO<never, E, A>;
  /**
   * Creates an IO from a function that might throw.
   */
  tryCatch: <A extends Type, E extends Type>(f: () => A, onError: (error: unknown) => E) => IO<never, E, A>;
  /**
   * Lifts a synchronous function into an IO-returning function.
   */
  liftSync: <Args extends unknown[], A extends Type>(f: (...args: Args) => A) => (...args: Args) => IO<never, never, A>;
  /**
   * Lifts a Promise-returning function into an IO-returning function.
   */
  liftPromise: <Args extends unknown[], A extends Type>(f: (...args: Args) => Promise<A>) => (...args: Args) => IO<never, unknown, A>;
  /**
   * Creates an IO from an Either.
   */
  fromEither: <E extends Type, A extends Type>(either: Either<E, A>) => IO<never, E, A>;
  /**
   * Creates an IO from an Option.
   */
  fromOption: <A extends Type>(option: Option<A>) => IO<never, void, A>;
  /**
   * Creates an IO from an Option with custom error.
   */
  fromOptionOrFail: <E extends Type, A extends Type>(option: Option<A>, onNone: () => E) => IO<never, E, A>;
  /**
   * Creates an IO from a Try.
   */
  fromTry: <A extends Type>(t: ReturnType<typeof Try<A>>) => IO<never, Error, A>;
  /**
   * Creates an IO from a result object with data/error pattern.
   * If error is present (truthy), fails with the error.
   * Otherwise succeeds with Option-wrapped data (None if data is null/undefined).
   *
   * This handles the common `{ data, error }` response pattern used by
   * Supabase, many REST APIs, and similar libraries.
   *
   * @example
   * ```typescript
   * const response = { data: user, error: null }
   * const io = IO.fromResult(response) // IO<never, null, Option<User>> -> Some(user)
   *
   * const emptyResponse = { data: null, error: null }
   * const emptyIo = IO.fromResult(emptyResponse) // IO<never, null, Option<User>> -> None
   *
   * const errorResponse = { data: null, error: new Error("Not found") }
   * const failedIo = IO.fromResult(errorResponse) // IO<never, Error, Option<null>> -> fails
   * ```
   */
  fromResult: <D extends Type, E extends Type>(result: {
    data: D | null;
    error: E | null;
  }) => IO<never, E, Option<D>>;
  /**
   * Creates an IO from an async thunk with typed error handling.
   * Catches any thrown errors and maps them using the provided function.
   * Supports cancellation via AbortSignal.
   *
   * This is a simpler alternative to `tryPromise` that takes a direct
   * error mapper function instead of an options object.
   *
   * @param f - Async function to execute (receives optional AbortSignal)
   * @param onError - Function to map caught errors to typed error E
   * @param signal - Optional AbortSignal for cancellation support
   *
   * @example
   * ```typescript
   * const io = IO.tryAsync(
   *   () => fetch('/api/users').then(r => r.json()),
   *   (e) => new ApiError(e)
   * )
   *
   * // With cancellation:
   * const controller = new AbortController()
   * const io = IO.tryAsync(
   *   (signal) => fetch('/api/users', { signal }).then(r => r.json()),
   *   (e) => new ApiError(e),
   *   controller.signal
   * )
   * controller.abort() // Cancels the request
   * ```
   */
  tryAsync: <A extends Type, E extends Type>(f: (signal?: AbortSignal) => Promise<A>, onError: (error: unknown) => E, signal?: AbortSignal) => IO<never, E, A>;
  /**
   * Creates an IO from an async function that returns { data, error }.
   * Handles both:
   * - Thrown errors (mapped via onThrow)
   * - Returned errors in the result object
   * Supports cancellation via AbortSignal.
   *
   * This is the most ergonomic way to wrap Supabase and similar API calls.
   *
   * @param f - Async function returning { data, error } object (receives optional AbortSignal)
   * @param onThrow - Function to map thrown errors to typed error E
   * @param config - Optional configuration for custom field names and cancellation
   *
   * @example
   * ```typescript
   * // Supabase query in one line:
   * const getUser = (id: string): IO<never, Error, Option<User>> =>
   *   IO.asyncResult(
   *     () => supabase.from('users').select('*').eq('id', id).single(),
   *     toError
   *   )
   *
   * // With custom field names:
   * const result = IO.asyncResult(
   *   () => customApi.fetch(),
   *   toError,
   *   { dataKey: 'result', errorKey: 'err' }
   * )
   *
   * // With cancellation:
   * const controller = new AbortController()
   * const getUser = IO.asyncResult(
   *   (signal) => supabase.from('users').abortSignal(signal).select('*').single(),
   *   toError,
   *   { signal: controller.signal }
   * )
   * controller.abort() // Cancels the request
   * ```
   */
  asyncResult: <D extends Type, E extends Type>(f: (signal?: AbortSignal) => Promise<Record<string, unknown>>, onThrow: (error: unknown) => E, config?: {
    dataKey?: string;
    errorKey?: string;
    signal?: AbortSignal;
  }) => IO<never, E, Option<D>>;
  /**
   * Creates an IO that requires a service identified by the tag.
   * The service must be provided before the effect can be run.
   *
   * @example
   * ```typescript
   * interface Logger {
   *   log(message: string): void
   * }
   * const Logger = Tag<Logger>("Logger")
   *
   * const program = IO.service(Logger).flatMap(logger =>
   *   IO.sync(() => logger.log("Hello!"))
   * )
   *
   * // Provide the service to run
   * program.provideService(Logger, consoleLogger).run()
   * ```
   */
  service: <S extends Type>(tag: Tag<S>) => IO<S, never, S>;
  /**
   * Accesses a service and applies a function to it.
   */
  serviceWith: <S extends Type, A extends Type>(tag: Tag<S>, f: (service: S) => A) => IO<S, never, A>;
  /**
   * Accesses a service and applies an effectful function to it.
   */
  serviceWithIO: <S extends Type, R extends Type, E extends Type, A extends Type>(tag: Tag<S>, f: (service: S) => IO<R, E, A>) => IO<S | R, E, A>;
  /**
   * Accesses multiple services and applies a function to them.
   * Provides a convenient way to work with multiple dependencies.
   *
   * @example
   * ```typescript
   * const program = IO.withServices(
   *   { logger: Logger, db: Database },
   *   ({ logger, db }) => {
   *     logger.log("Querying...")
   *     return db.query("SELECT * FROM users")
   *   }
   * )
   * ```
   */
  withServices: <Services extends Record<string, Tag<Type>>, A extends Type>(services: Services, f: (ctx: { [K in keyof Services]: TagService<Services[K]>; }) => A | Promise<A>) => IO<TagService<Services[keyof Services]>, unknown, A>;
  /**
   * Runs all IOs in parallel and collects results.
   */
  all: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]) => IO<R, E, readonly A[]>;
  /**
   * Runs IOs in sequence, returning the first success or last failure.
   */
  firstSuccessOf: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]) => IO<R, E, A>;
  /**
   * Creates an IO that sleeps for the specified duration.
   */
  sleep: (ms: number) => IO<never, never, void>;
  /**
   * Effectful stateful loop — the value-driven dual of the retry family.
   *
   * Threads state `S` through an effectful `step` until `done(state)` holds, or
   * the `max` bound is reached. Semantics:
   *
   * - `done(seed)` is evaluated **before** the first `step` — an already-satisfied
   *   seed returns immediately without executing the effect.
   * - The first `E` failure short-circuits the loop and propagates.
   * - `max` defaults to `10_000` and caps total step invocations to keep every
   *   loop bounded by construction. Callers running larger iterations must set
   *   `max` explicitly.
   * - Stack-safe: recursion happens via IO's `flatMap` trampoline, not the JS
   *   call stack.
   *
   * @example
   * ```ts
   * // Poll for a completed job, threading the response through state.
   * const settled = await IO.iterate(
   *   { status: "pending" as JobStatus },
   *   (state) => fetchJob(state.id),
   *   (state) => state.status === "done" || state.status === "failed",
   *   { max: 30 },
   * ).runEither()
   * ```
   *
   * @param seed - Initial state.
   * @param step - Effect producing the next state from the current state.
   * @param done - Pure sync predicate over the state.
   * @param opts.max - Maximum step invocations (default `10_000`).
   * @returns The satisfying state, or `RepeatExhausted<S>` (carrying the last
   *   observed state) if the bound is reached first.
   */
  iterate: <R extends Type, E extends Type, S extends Type>(seed: S, step: (state: S) => IO<R, E, S>, done: (state: S) => boolean, opts?: {
    readonly max?: number;
  }) => IO<R, E | RepeatExhausted<S>, S>;
  /**
   * Creates an IO that never completes.
   */
  never: <A extends Type = never>() => IO<never, never, A>;
  /**
   * Creates a unit IO.
   */
  readonly unit: IO<never, never, void>;
  /**
   * Converts a nullable value to an IO.
   */
  fromNullable: <A extends Type>(value: A | null | undefined) => IO<never, void, A>;
  /**
   * Creates an IO that is immediately interrupted.
   */
  interrupt: () => IO<never, never, never>;
  /**
   * Ensures a resource is properly released after use.
   * The release function always runs, even if use fails.
   *
   * @example
   * ```typescript
   * const withFile = IO.bracket(
   *   IO.sync(() => openFile("data.txt")),   // acquire
   *   file => IO.async(() => file.read()),    // use
   *   file => IO.sync(() => file.close())     // release
   * )
   * ```
   */
  bracket: <R extends Type, E extends Type, A extends Type, B extends Type>(acquire: IO<R, E, A>, use: (a: A) => IO<R, E, B>, release: (a: A) => IO<R, never, void>) => IO<R, E, B>;
  /**
   * Alias for bracket with a more descriptive name.
   */
  acquireRelease: <R extends Type, E extends Type, A extends Type, B extends Type>(acquire: IO<R, E, A>, use: (a: A) => IO<R, E, B>, release: (a: A) => IO<R, never, void>) => IO<R, E, B>;
  /**
   * Like `bracket`, but the release callback receives the Exit of the use-step.
   * Use this when cleanup needs to branch on whether `use` succeeded or failed —
   * e.g., emit a different audit event on `Success` vs `Failure`.
   *
   * The release effect always runs (whether use succeeded, failed, or was
   * interrupted). If `acquire` itself fails, release is not called.
   *
   * @example
   * ```typescript
   * IO.bracketExit(
   *   appendEvent({ event: "job_start" }),
   *   () => body,
   *   (_a, exit) =>
   *     exit.isSuccess()
   *       ? appendEvent({ event: "job_complete" })
   *       : appendEvent({ event: "job_failed", error: String(exit.toValue().value) })
   * )
   * ```
   */
  bracketExit: <R extends Type, E extends Type, A extends Type, B extends Type>(acquire: IO<R, E, A>, use: (a: A) => IO<R, E, B>, release: (a: A, exit: Exit<E, B>) => IO<R, never, void>) => IO<R, E, B>;
  /**
   * Races multiple effects, returning the first to complete.
   * Note: Other effects are NOT cancelled (JS limitation).
   *
   * @example
   * ```typescript
   * const result = await IO.race([
   *   IO.sleep(1000).map(() => "slow"),
   *   IO.sleep(100).map(() => "fast")
   * ]).run() // "fast"
   * ```
   */
  race: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]) => IO<R, E, A>;
  /**
   * Returns the first effect to succeed, or fails if all fail.
   *
   * @example
   * ```typescript
   * const result = await IO.any([
   *   IO.fail("error1"),
   *   IO.succeed("success"),
   *   IO.fail("error2")
   * ]).run() // "success"
   * ```
   */
  any: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]) => IO<R, E, A>;
  /**
   * Executes an effect for each element in the array, collecting results.
   *
   * @example
   * ```typescript
   * const results = await IO.forEach([1, 2, 3], n =>
   *   IO.sync(() => n * 2)
   * ).run() // [2, 4, 6]
   * ```
   */
  forEach: <R extends Type, E extends Type, A extends Type, B extends Type>(items: readonly A[], f: (a: A) => IO<R, E, B>) => IO<R, E, readonly B[]>;
  /**
   * Executes effects for each element in parallel (limited concurrency coming later).
   * Alias for forEach.
   */
  forEachPar: <R extends Type, E extends Type, A extends Type, B extends Type>(items: readonly A[], f: (a: A) => IO<R, E, B>) => IO<R, E, readonly B[]>;
  /**
   * Creates a timeout effect that fails with TimeoutError.
   */
  timeout: <R extends Type, E extends Type, A extends Type>(effect: IO<R, E, A>, ms: number) => IO<R, E | TimeoutError, A>;
  /**
   * Creates an IO from a generator function.
   * This enables do-notation style programming.
   *
   * @example
   * ```typescript
   * const program = IO.gen(function* () {
   *   const a = yield* IO.succeed(1)
   *   const b = yield* IO.succeed(2)
   *   return a + b
   * })
   * ```
   */
  gen: <A extends Type>(f: () => Generator<IOYieldable, A, any>) => IO<never, any, A>;
  /**
   * Starts a Do-builder context for binding values.
   * This enables do-notation style programming without generators.
   *
   * @example
   * ```typescript
   * const program = IO.Do
   *   .bind("user", () => getUser("123"))
   *   .bind("posts", ({ user }) => getPosts(user.id))
   *   .let("count", ({ posts }) => posts.length)
   *   .map(({ user, posts, count }) => ({ user, posts, count }))
   * ```
   */
  readonly Do: DoBuilder<never, never, Record<never, never>>;
};
/**
 * An IO with no requirements and no error
 */
type UIO<A extends Type> = IO<never, never, A>;
/**
 * An IO with no requirements
 */
type Task<E extends Type, A extends Type> = IO<never, E, A>;
/**
 * An IO with no error
 */
type RIO<R extends Type, A extends Type> = IO<R, never, A>;
//#endregion
//#region src/io/TestClock.d.ts
/**
 * TestClock interface for controlling time in tests
 */
interface TestClock {
  /**
   * Current virtual time in milliseconds
   */
  readonly currentTime: number;
  /**
   * Advances the clock by the specified duration.
   * All scheduled tasks with a time <= new current time will be executed.
   * @param ms - Milliseconds to advance
   */
  advance(ms: number): Promise<void>;
  /**
   * Sets the clock to a specific time.
   * @param ms - The absolute time to set
   */
  setTime(ms: number): Promise<void>;
  /**
   * Runs all pending tasks immediately.
   */
  runAll(): Promise<void>;
  /**
   * Gets the number of pending scheduled tasks.
   */
  readonly pendingCount: number;
  /**
   * Sleeps for the specified duration using virtual time.
   * @param ms - Milliseconds to sleep
   */
  sleep(ms: number): Promise<void>;
}
/**
 * Service tag for TestClock
 */
declare const TestClockTag: Tag<TestClock>;
/**
 * TestClock companion object with factory methods
 */
declare const TestClock: {
  /**
   * Creates a new TestClock instance
   */
  make: () => TestClock;
  /**
   * Tag for dependency injection
   */
  tag: Tag<TestClock>;
  /**
   * Creates a test environment with a TestClock and runs the test function.
   *
   * @example
   * ```typescript
   * await TestClock.test(async (clock) => {
   *   const result = await IO.sleep(100).map(() => "done")
   *     .pipe(clock.runWithClock)
   *   expect(result).toBe("done")
   * })
   * ```
   */
  test: <A>(f: (clock: TestClock) => Promise<A>) => Promise<A>;
  /**
   * Creates an IO that accesses the TestClock from the environment.
   */
  get: IO<TestClock, never, TestClock>;
  /**
   * Creates an IO that advances the TestClock.
   */
  advance: (ms: number) => IO<TestClock, never, void>;
  /**
   * Creates an IO that sets the TestClock time.
   */
  setTime: (ms: number) => IO<TestClock, never, void>;
  /**
   * Creates an IO that runs all pending tasks.
   */
  runAll: IO<TestClock, unknown, void>;
  /**
   * Creates a context with a TestClock for testing.
   */
  context: () => {
    clock: TestClock;
    context: ReturnType<typeof Context.make<TestClock>>;
  };
};
/**
 * TestContext provides a complete test environment with mocked services.
 */
interface TestContext<R extends Type> {
  /**
   * The context containing test services
   */
  readonly context: ReturnType<typeof Context.empty<R>>;
  /**
   * The TestClock for controlling time
   */
  readonly clock: TestClock;
  /**
   * Adds a service to the test context
   */
  withService<S extends Type>(tag: Tag<S>, service: S): TestContext<R & S>;
  /**
   * Provides the test context to an IO effect and runs it
   */
  run<E extends Type, A extends Type>(effect: IO<R, E, A>): Promise<A>;
}
/**
 * Creates a TestContext for testing IO effects with mocked services.
 *
 * @example
 * ```typescript
 * const ctx = TestContext.make()
 *   .withService(Logger, mockLogger)
 *   .withService(Database, mockDb)
 *
 * const result = await ctx.run(myProgram)
 * ```
 */
declare const TestContext: {
  /**
   * Creates a new empty TestContext
   */
  make: <R extends Type = never>() => TestContext<R>;
  /**
   * Creates a TestContext with a TestClock already provided
   */
  withClock: () => TestContext<TestClock>;
};
//#endregion
//#region src/fetch/HttpError.d.ts
type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
type NetworkError = {
  readonly _tag: "NetworkError";
  readonly url: string;
  readonly method: HttpMethod;
  readonly cause: unknown;
};
type HttpStatusError = {
  readonly _tag: "HttpStatusError";
  readonly url: string;
  readonly method: HttpMethod;
  readonly status: number;
  readonly statusText: string;
  readonly body: string;
};
/**
 * Raised when a successful HTTP response could not be decoded into the
 * caller's expected shape — JSON parse failure, a `decode: Decoder<T>` that
 * returned `Left(DecoderError)`, a throwing `decodeUnsafe` / `validate`, etc.
 * In practice `cause` is a `DecoderError` (when produced by the `decode`
 * path) or an `Error` (otherwise) — but the field is typed `unknown` for
 * back-compat with the 1.0.x runtime.
 */
type DecodeError = {
  readonly _tag: "DecodeError";
  readonly url: string;
  readonly method: HttpMethod;
  readonly body: string;
  readonly cause: unknown;
};
/**
 * More descriptive alias for `DecodeError` — clarifies that this is the
 * HTTP-level wrapper for response decoding failures, distinct from the
 * structural `DecoderError` tree it usually carries in `cause`. Both names
 * refer to the same `_tag: "DecodeError"` variant.
 */
type ResponseDecodeError = DecodeError;
type HttpError = NetworkError | HttpStatusError | DecodeError;
declare const HttpError: {
  readonly _tag: "HttpError";
} & {
  networkError: (url: string, method: HttpMethod, cause: unknown) => NetworkError;
  httpStatusError: (url: string, method: HttpMethod, status: number, statusText: string, body: string) => HttpStatusError;
  decodeError: (url: string, method: HttpMethod, body: string, cause: unknown) => DecodeError;
  isNetworkError: (error: HttpError) => error is NetworkError;
  isHttpStatusError: (error: HttpError) => error is HttpStatusError;
  isDecodeError: (error: HttpError) => error is DecodeError;
  match: <T>(error: HttpError, patterns: {
    readonly NetworkError: (e: NetworkError) => T;
    readonly HttpStatusError: (e: HttpStatusError) => T;
    readonly DecodeError: (e: DecodeError) => T;
  }) => T;
};
//#endregion
//#region src/fetch/HttpRequest.d.ts
type ParseMode = "json" | "text" | "blob" | "arrayBuffer" | "raw";
/**
 * Typed query-parameter record. Scalar values (string | number | boolean) are
 * `String()`-coerced; arrays repeat the key (`{ tag: ["a", "b"] }` → `tag=a&tag=b`);
 * `undefined` and `null` values are dropped (so callers can write
 * `{ foo: maybe.toNullable() }` without conditionals); special characters are
 * percent-encoded via `URLSearchParams`.
 *
 * Nested objects are not supported (the type prevents them at compile time).
 */
type HttpQueryParams = Readonly<Record<string, string | number | boolean | readonly (string | number | boolean)[] | undefined | null>>;
interface HttpRequestOptions<T = unknown> {
  readonly url: string;
  readonly method: HttpMethod;
  readonly headers?: Record<string, string>;
  readonly body?: unknown;
  readonly signal?: AbortSignal;
  readonly parseAs?: ParseMode;
  /**
   * Query-string parameters appended to the URL. Merges with any query string
   * already present in `url`. See {@link HttpQueryParams} for encoding rules.
   */
  readonly params?: HttpQueryParams;
  /**
   * Either-returning response decoder. Returns `Left(DecoderError)` on
   * failure; the framework maps that to `HttpError.DecodeError(cause: DecoderError)`.
   * The recursive `DecoderError` tree preserves structural failure info
   * (paths, child errors) for diagnosis and rendering.
   *
   * For adapters whose primary API throws (e.g. Zod's `.parse`), use an
   * adapter package (e.g. `functype-zod`'s `Decoder.fromZod(schema)`) or
   * wrap the throwing function in a tiny custom decoder. The deprecated
   * `validate` field is also still accepted for back-compat.
   */
  readonly decode?: Decoder$1<T>;
  /**
   * @deprecated Use `decode` (Either-returning). For throw-pattern adapters
   *   like Zod's `.parse`, prefer an adapter package (`functype-zod`'s
   *   `Decoder.fromZod`). `validate` is kept for back-compat with the 1.0.x
   *   API and will be removed in a future major release. Throwing maps to
   *   `HttpError.DecodeError(cause: Error)`.
   */
  readonly validate?: (data: unknown) => T;
  /**
   * Whether to flatten functype ADTs in the request body to their primitive
   * projections (Option → nullable, Either → right-value-or-throw-on-Left,
   * List → array, Try → success-value-or-throw, Map → record) before serializing.
   * Default `true` — matches the wire shape external JSON APIs expect.
   *
   * Set to `false` to emit each ADT's canonical `{_tag, value}` form via
   * `toValue()` for functype-to-functype services where both ends round-trip
   * the tagged shape via `Decoder.tagged.*`.
   */
  readonly flatten?: boolean;
}
interface HttpMethodOptions<T = unknown> {
  readonly headers?: Record<string, string>;
  readonly body?: unknown;
  readonly signal?: AbortSignal;
  readonly parseAs?: ParseMode;
  readonly decode?: Decoder$1<T>;
  /** @deprecated Use `decode` (Either-returning) or an adapter package for throw-pattern validators. */
  readonly validate?: (data: unknown) => T;
  readonly flatten?: boolean;
  /**
   * Query-string parameters appended to the URL. See {@link HttpQueryParams}.
   */
  readonly params?: HttpQueryParams;
}
interface HttpResponse<T> {
  readonly data: T;
  readonly status: number;
  readonly statusText: string;
  readonly headers: Headers;
}
/**
 * The assembled, pre-wire view of a request that `HttpClientConfig.beforeRequest`
 * receives and may return a transformed copy of. URL is resolved against
 * `baseUrl`; headers reflect the `defaultHeaders` + per-call merge. The
 * response-side decoders (`decode` / `validate`) are intentionally not
 * exposed here — they aren't part of the wire request and apply to the
 * response. The `flatten` flag IS exposed because it affects how `body`
 * is serialized.
 */
interface HttpRequestView {
  readonly url: string;
  readonly method: HttpMethod;
  readonly headers?: Record<string, string>;
  readonly body?: unknown;
  readonly signal?: AbortSignal;
  readonly parseAs?: ParseMode;
  readonly flatten?: boolean;
}
//#endregion
//#region src/fetch/HttpClient.d.ts
interface HttpClientConfig {
  readonly baseUrl?: string;
  readonly defaultHeaders?: Record<string, string>;
  readonly fetch?: typeof globalThis.fetch;
  /**
   * Effectful transformer that runs after `defaultHeaders` and per-call headers
   * are merged, but before the request is sent. Returning a failed IO short-
   * circuits the call with the produced `HttpError`. Compose multiple concerns
   * (request IDs, auth refresh, logging) with standard IO operators — the
   * request side becomes symmetric with the response chain (`.tap`, `.map`,
   * `.flatMap`, `.catchTag`).
   *
   * @example
   * ```ts
   * const addRequestId = (r: HttpRequestView): HttpRequestView => ({
   *   ...r,
   *   headers: { ...r.headers, "x-request-id": crypto.randomUUID() },
   * })
   *
   * const addBearer = (getToken: () => Promise<string>) =>
   *   (r: HttpRequestView): IO<never, HttpError, HttpRequestView> =>
   *     IO.tryPromise({
   *       try: () => getToken(),
   *       catch: (e) => HttpError.networkError(r.url, r.method, e),
   *     }).map((token) => ({
   *       ...r,
   *       headers: { ...r.headers, Authorization: `Bearer ${token}` },
   *     }))
   *
   * const api = Http.client({
   *   baseUrl: "https://api.example.com",
   *   beforeRequest: (r) =>
   *     IO.succeed(r)
   *       .map(addRequestId)
   *       .flatMap(addBearer(getToken))
   *       .tap((req) => logger.info(req.method, req.url)),
   * })
   * ```
   */
  readonly beforeRequest?: (request: HttpRequestView) => IO<never, HttpError, HttpRequestView>;
  /**
   * Effectful transformer that runs after the response is parsed (and the
   * decoder, if any, succeeds) but before the IO resolves to the caller.
   * Returning a failed IO surfaces the error in place of the response.
   *
   * **Only runs on the success path.** `HttpStatusError` (non-2xx),
   * `DecodeError` (validation failure), and `NetworkError` (fetch / abort)
   * skip this hook and surface directly. For *error*-side observability and
   * recovery (refresh-on-401, error logging), use `.catchTag(...)` /
   * `.tapError(...)` at the call site.
   *
   * The hook receives `HttpResponse<unknown>` — body shape is opaque here
   * because hooks are response-shape-agnostic. The per-call decoder narrows
   * `data` to the typed value before the response reaches the caller, but
   * the hook itself sees `unknown`.
   *
   * @example
   * ```ts
   * const api = Http.client({
   *   baseUrl: "https://api.example.com",
   *   afterResponse: (response) =>
   *     IO.succeed(response)
   *       .tap((r) => logger.info("response", { status: r.status }))
   *       .map((r) => ({ ...r, headers: redactSensitiveHeaders(r.headers) })),
   * })
   *
   * // Refresh-on-401 is a .catchTag pattern, NOT an afterResponse pattern:
   * api.get("/me", { decode })
   *   .catchTag("HttpStatusError", (e) =>
   *     e.status === 401 ? refreshToken().flatMap(() => api.get("/me", { decode })) : IO.fail(e),
   *   )
   * ```
   */
  readonly afterResponse?: (response: HttpResponse<unknown>) => IO<never, HttpError, HttpResponse<unknown>>;
}
declare const HttpClient: Tag<HttpClientConfig>;
//#endregion
//#region src/fetch/Http.d.ts
type HttpMethods = {
  readonly request: <T = unknown>(options: HttpRequestOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  readonly get: <T = unknown>(url: string, options?: HttpMethodOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  readonly post: <T = unknown>(url: string, options?: HttpMethodOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  readonly put: <T = unknown>(url: string, options?: HttpMethodOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  readonly patch: <T = unknown>(url: string, options?: HttpMethodOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  readonly delete: <T = unknown>(url: string, options?: HttpMethodOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  readonly head: (url: string, options?: HttpMethodOptions<void>) => IO<never, HttpError, HttpResponse<void>>;
  readonly options: (url: string, options?: HttpMethodOptions<void>) => IO<never, HttpError, HttpResponse<void>>;
};
declare const Http: {
  readonly _tag: "Http";
} & {
  request: <T = unknown>(options: HttpRequestOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  get: <T = unknown>(url: string, options?: HttpMethodOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  post: <T = unknown>(url: string, options?: HttpMethodOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  put: <T = unknown>(url: string, options?: HttpMethodOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  patch: <T = unknown>(url: string, options?: HttpMethodOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  delete: <T = unknown>(url: string, options?: HttpMethodOptions<T>) => IO<never, HttpError, HttpResponse<T>>;
  head: (url: string, options?: HttpMethodOptions<void>) => IO<never, HttpError, HttpResponse<void>>;
  options: (url: string, options?: HttpMethodOptions<void>) => IO<never, HttpError, HttpResponse<void>>;
  client: (config: HttpClientConfig) => HttpMethods;
};
//#endregion
//#region src/foldable/index.d.ts
/**
 * Structural type for sum types that support pattern-match fold (Option, Either, Try, etc.).
 * Uses duck typing so any type with the right fold signature works, without requiring a shared interface.
 */
type PatternFoldable<A> = {
  fold<B>(onEmpty: () => B, onValue: (value: A) => B): B;
};
/**
 * Utility functions for working with sum-type Foldable data structures.
 * These utilities use pattern-match fold semantics and are designed for
 * sum types (Option, Either, Try) — not collections.
 */
declare const FoldableUtils: {
  /**
   * Converts a sum type to an Option
   *
   * @param foldable - The sum type to convert
   * @returns An Option containing the value, or None if empty
   */
  toOption: <A extends Type>(foldable: PatternFoldable<A>) => Option<A>;
  /**
   * Converts a sum type to a List
   *
   * @param foldable - The sum type to convert
   * @returns A List containing the value(s), or empty List if empty
   */
  toList: <A extends Type>(foldable: PatternFoldable<A>) => List<A>;
  /**
   * Converts a sum type to an Either
   *
   * @param foldable - The sum type to convert
   * @param left - The value to use for Left if empty
   * @returns Either.Right with the value if non-empty, or Either.Left with left if empty
   */
  toEither: <A extends Type, E>(foldable: PatternFoldable<A>, left: E) => Either<E, A>;
  /**
   * Checks if the sum type is empty
   *
   * @param foldable - The sum type to check
   * @returns true if empty, false otherwise
   */
  isEmpty: <A extends Type>(foldable: PatternFoldable<A>) => boolean;
  /**
   * Calculates the size of the sum type (0 or 1)
   *
   * @param foldable - The sum type to measure
   * @returns The size (0 if empty, 1 if non-empty)
   */
  size: <A extends Type>(foldable: PatternFoldable<A>) => number;
};
//#endregion
//#region src/hkt/index.d.ts
/**
 * Type function for representing higher-kinded types
 */
type Kind<F, A> = F extends ((arg: infer T) => infer R) ? R : never;
/**
 * Type constructors for common Functype data types
 */
type OptionKind = <A>(a: A) => Option<A>;
type ListKind = <A>(a: A) => List<A>;
type EitherKind<E> = <A>(a: A) => Either<E, A>;
type TryKind = <A>(a: A) => Try<A>;
/**
 * Generic container types for type-safe operations
 * @internal
 */
type Mappable<T> = {
  map<U>(f: (value: T) => U): unknown;
};
/**
 * @internal
 */
type Flattenable = {
  flatten(): unknown;
};
/**
 * @internal
 */
type FlatMappable<T> = {
  flatMap<U>(f: (value: T) => unknown): unknown;
};
/**
 * Universal type that includes all potential return types from the HKT functions
 * Used to avoid 'any' usage which the linter prohibits
 */
type UniversalContainer = Option<unknown> | List<unknown> | Either<unknown, unknown> | Try<unknown>;
/**
 * HKT provides utilities for working with higher-kinded types
 * This allows writing generic code that works across different
 * container types like Option, List, Either, etc.
 */
declare const HKT: {
  (): {
    _tag: string;
    map: <F, A, B>(fa: unknown, f: (a: A) => B) => unknown;
    flatten: <F, A>(ffa: unknown) => unknown;
    flatMap: <F, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
    ap: <F, A, B>(ff: unknown, fa: unknown) => unknown;
    sequence: <F, G, A>(fga: unknown) => unknown;
    traverse: <F, G, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
    _type: string;
  };
  map<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => B): unknown;
  flatten<F = unknown, A = unknown>(ffa: unknown): unknown;
  flatMap<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
  ap<F = unknown, A = unknown, B = unknown>(ff: unknown, fa: unknown): unknown;
  sequence<F = unknown, G = unknown, A = unknown>(fga: unknown): unknown;
  traverse<F = unknown, G = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
  isOption: <T extends Type>(value: unknown) => value is Option<T> & Mappable<T> & FlatMappable<T>;
  isList: <T extends Type>(value: unknown) => value is List<T> & Mappable<T> & Flattenable & FlatMappable<T>;
  isEither: <E extends Type, A extends Type>(value: unknown) => value is Either<E, A> & Mappable<A> & FlatMappable<A>;
  isTry: <T extends Type>(value: unknown) => value is Try<T> & Mappable<T> & FlatMappable<T>;
};
//#endregion
//#region src/identity/Identity.d.ts
/**
 * Identity — a trivial container carrying a single tagged value.
 * Covariant in T (`<out T>`). `isSame` takes `Identity<unknown>` so that
 * cross-type equality checks (semantically always `false` for unrelated types)
 * don't block variance — mirroring the `contains(unknown)` pattern used on
 * List/Set/Map.
 */
type Identity<out T> = {
  readonly id: T;
  isSame?: (other: Identity<unknown>) => boolean;
};
declare const Identity: (<T>(value: T) => Identity<T>) & {
  /**
   * Creates an Identity. Alias for Identity constructor.
   * @param value - The value to wrap
   * @returns Identity instance
   */
  of: <T>(value: T) => Identity<T>;
  /**
   * Creates an Identity. Same as of.
   * @param value - The value to wrap
   * @returns Identity instance
   */
  pure: <T>(value: T) => Identity<T>;
};
//#endregion
//#region src/lazy/Lazy.d.ts
/**
 * Lazy type module
 * @module Lazy
 * @category Core
 */
/**
 * The Lazy type represents a computation that is deferred until needed.
 * It provides memoization and safe evaluation with integration to Option, Either, and Try.
 * @typeParam T - The type of the value to be computed
 */
interface Lazy<out T extends Type> extends FunctypeBase<T, "Lazy">, Extractable<T>, Pipe<T> {
  /** Tag identifying this as a Lazy type */
  readonly _tag: "Lazy";
  /** Whether the computation has been evaluated */
  readonly isEvaluated: boolean;
  /**
   * Returns the computed value or a default value if computation fails.
   * Result widens to `T | T2` (Scala: `getOrElse[B >: A](default: B): B`).
   */
  orElse<T2 extends Type>(defaultValue: T2): T | T2;
  /**
   * Returns the computed value or null if computation fails
   * @returns The computed value or null
   */
  orNull(): T | null;
  /**
   * Returns the computed value or throws an error if computation fails
   * @param error - Optional custom error to throw. If not provided, throws the computation error or a default error
   * @returns The computed value
   * @throws The specified error, computation error, or a default error
   */
  orThrow(error?: Error): T;
  /**
   * Returns this Lazy if computation succeeds, otherwise returns the alternative Lazy.
   * The alternative may carry a different type; result is `Lazy<T | T2>`.
   */
  or<T2 extends Type>(alternative: Lazy<T2>): Lazy<T | T2>;
  /**
   * Maps the value inside the Lazy using the provided function
   * @param f - The mapping function
   * @returns A new Lazy containing the mapped value
   */
  map<U extends Type>(f: (value: T) => U): Lazy<U>;
  /**
   * Applies a wrapped function to a wrapped value (Applicative pattern)
   * @param ff - A Lazy containing a function from T to U
   * @returns A new Lazy containing the result
   */
  ap<U extends Type>(ff: Lazy<(value: T) => U>): Lazy<U>;
  /**
   * Maps the value inside the Lazy using an async function
   * @param f - The async mapping function
   * @returns A Promise of a new Lazy containing the mapped value
   */
  mapAsync<U extends Type>(f: (value: T) => Promise<U>): Promise<Lazy<U>>;
  /**
   * Maps the value using a function that returns a Lazy
   * @param f - The mapping function returning a Lazy
   * @returns A new Lazy containing the flattened result
   */
  flatMap<U extends Type>(f: (value: T) => Lazy<U>): Lazy<U>;
  /**
   * Maps the value using an async function that returns a Lazy
   * @param f - The async mapping function returning a Lazy
   * @returns A Promise of a new Lazy containing the flattened result
   */
  flatMapAsync<U extends Type>(f: (value: T) => Promise<Lazy<U>>): Promise<Lazy<U>>;
  /**
   * Returns a Lazy that filters the value based on a predicate
   * @param predicate - The predicate function
   * @returns A Lazy containing an Option of the value
   */
  filter(predicate: (value: T) => boolean): Lazy<Option<T>>;
  /**
   * Recovers from a failed computation by providing an alternative value
   * @param f - Function that takes the error and returns a recovery value
   * @returns A new Lazy that will use the recovery function if computation fails
   */
  recover(f: (error: unknown) => T): Lazy<T>;
  /**
   * Recovers from a failed computation by providing an alternative Lazy
   * @param f - Function that takes the error and returns a recovery Lazy
   * @returns A new Lazy that will use the recovery Lazy if computation fails
   */
  recoverWith(f: (error: unknown) => Lazy<T>): Lazy<T>;
  /**
   * Evaluates the computation and returns it as an Option
   * @returns Some containing the value if successful, None if computation fails
   */
  toOption(): Option<T>;
  /**
   * Evaluates the computation and returns it as an Either
   * @returns Right containing the value if successful, Left containing the error if computation fails
   */
  toEither(): Either<unknown, T>;
  /**
   * Evaluates the computation and returns it as an Either with a mapped error
   * @param mapError - Function to map the error
   * @returns Right containing the value if successful, Left containing the mapped error if computation fails
   */
  toEitherWith<E>(mapError: (error: unknown) => E): Either<E, T>;
  /**
   * Evaluates the computation and returns it as a Try
   * @returns Try containing the result of the computation
   */
  toTry(): Try<T>;
  /**
   * Applies an effect function to the value if computation succeeds
   * @param f - The effect function
   * @returns This Lazy for chaining
   */
  tap(f: (value: T) => void): Lazy<T>;
  /**
   * Applies an effect function to the error if computation fails
   * @param f - The effect function for errors
   * @returns This Lazy for chaining
   */
  tapError(f: (error: unknown) => void): Lazy<T>;
  /**
   * Pattern matching on the Lazy value
   * @param f - Function to apply to the computed value
   * @returns The result of applying f to the computed value
   */
  fold<U>(f: (value: T) => U): U;
  /**
   * Pattern matching with success and failure handlers
   * @param onFailure - Function to handle computation failure
   * @param onSuccess - Function to handle successful computation
   * @returns The result of the appropriate handler
   */
  foldWith<U>(onFailure: (error: unknown) => U, onSuccess: (value: T) => U): U;
  /**
   * Left fold operation
   * @param z - Initial value
   * @returns Function that takes an operator and applies it
   */
  foldLeft: <B>(z: B) => (op: (b: B, a: T) => B) => B;
  /**
   * Right fold operation
   * @param z - Initial value
   * @returns Function that takes an operator and applies it
   */
  foldRight: <B>(z: B) => (op: (a: T, b: B) => B) => B;
  /**
   * Pattern matching for the Lazy type
   * @param patterns - Object with handler for Lazy pattern
   * @returns The result of the matched handler
   */
  match<R>(patterns: {
    Lazy: (value: T) => R;
  }): R;
  /**
   * Creates a string representation of the Lazy
   * @returns String representation showing evaluation status
   */
  toString(): string;
  /**
   * Converts the Lazy to a value object.
   *
   * **Forces the thunk** as a side effect — Lazy serialization (and projection
   * to a plain value object) cannot represent an unevaluated thunk in JSON;
   * forcing is the only way to produce a complete projection. If the thunk
   * threw, the failure is captured in the `error` field (real Error, with
   * full prototype intact for in-memory inspection — `toJSON` projects to
   * `SerializedError` for the wire).
   *
   * Changed in 1.2.0 — pre-1.2.0 Lazy emitted `{_tag, evaluated, value?}`
   * without forcing. See `docs/archive/proposals/serializable-audit-q1-q2.md`.
   */
  toValue(): {
    _tag: "Lazy";
    value: T;
  } | {
    _tag: "Lazy";
    error: Error;
  };
  /**
   * Custom JSON serialization. Forces the thunk (see `toValue` for the
   * side-effect contract). Emits `{"@functype":"Lazy","_tag":"Lazy","value":T}`
   * on success, or `{"@functype":"Lazy","_tag":"Lazy","error":SerializedError}`
   * if the thunk threw — see error-envelope.ts for round-trip semantics.
   */
  toJSON(): {
    "@functype": "Lazy";
    _tag: "Lazy";
    value: T;
  } | {
    "@functype": "Lazy";
    _tag: "Lazy";
    error: SerializedError;
  };
}
/**
 * Creates a Lazy computation that defers evaluation until needed.
 * Results are memoized after first evaluation.
 *
 * @example
 * // Basic lazy evaluation
 * const expensive = Lazy(() => {
 *   console.log("Computing...")
 *   return 42
 * })
 * // Nothing printed yet
 * const result = expensive.orThrow() // Prints "Computing..." and returns 42
 * const cached = expensive.orThrow() // Returns 42 without printing
 *
 * @example
 * // Error handling
 * const risky = Lazy(() => {
 *   if (Math.random() > 0.5) throw new Error("Failed")
 *   return "Success"
 * })
 * const safe = risky.orElse("Default") // Returns "Success" or "Default"
 * const option = risky.toOption() // Some("Success") or None
 * const either = risky.toEither() // Right("Success") or Left(Error)
 *
 * @example
 * // Chaining computations
 * const result = Lazy(() => 10)
 *   .map(x => x * 2)
 *   .flatMap(x => Lazy(() => x + 5))
 *   .recover(err => 0)
 *   .orThrow() // 25
 *
 * @example
 * // Integration with functype
 * const userOption = Option({ id: 1, name: "Alice" })
 * const userName = Lazy.fromOption(userOption, () => ({ id: 0, name: "Anonymous" }))
 *   .map(user => user.name)
 *   .orThrow() // "Alice"
 */
declare const Lazy: (<T extends Type>(thunk: () => T) => Lazy<T>) & {
  /**
   * Creates a Lazy from a thunk (deferred computation)
   * @param thunk - Function that computes the value
   * @returns A new Lazy instance
   */
  of: <T extends Type>(thunk: () => T) => Lazy<T>;
  /**
   * Creates a Lazy from an immediate value
   * @param value - The value to wrap
   * @returns A new Lazy instance that returns the value
   */
  fromValue: <T extends Type>(value: T) => Lazy<T>;
  /**
   * Creates a Lazy from an Option
   * @param option - The Option to convert
   * @param defaultThunk - Thunk to compute default value if Option is None
   * @returns A new Lazy instance
   */
  fromOption: <T extends Type>(option: Option<T>, defaultThunk: () => T) => Lazy<T>;
  /**
   * Creates a Lazy from a Try
   * @param tryValue - The Try to convert
   * @returns A new Lazy instance
   */
  fromTry: <T extends Type>(tryValue: Try<T>) => Lazy<T>;
  /**
   * Creates a Lazy from an Either
   * @param either - The Either to convert
   * @returns A new Lazy instance
   */
  fromEither: <E, T extends Type>(either: Either<E, T>) => Lazy<T>;
  /**
   * Creates a Lazy that will throw an error since promises need to be awaited first
   * @param promise - The Promise to convert
   * @returns A new Lazy instance that throws an error
   */
  fromPromise: <T extends Type>(_promise: Promise<T>) => Lazy<T>;
  /**
   * Creates a failed Lazy that will throw when evaluated
   * @param error - The error to throw
   * @returns A new Lazy instance that throws the error
   */
  fail: <T extends Type>(error: unknown) => Lazy<T>;
  /**
   * Creates an already-evaluated Lazy. Used by `fromJSON` to reconstruct a
   * Lazy whose thunk was forced at serialize time — there is no original
   * thunk to defer because a closure cannot be JSON-serialized.
   *
   * Functionally equivalent to `Lazy.fromValue` but reads with intent at
   * the call site.
   */
  evaluated: <T extends Type>(value: T) => Lazy<T>;
  /**
   * Reconstruct a Lazy from a JSON envelope emitted by `serialize().toJSON()`
   * or instance `toJSON()`. Verifies `@functype === "Lazy"`. Success envelopes
   * become already-evaluated Lazies via `Lazy.evaluated`; failure envelopes
   * become Lazies whose forcing rethrows the deserialized Error (see
   * error-envelope.ts — `instanceof SomeError` does NOT survive but `name`
   * does).
   */
  fromJSON: <T extends Type>(json: string) => Lazy<T>;
};
//#endregion
//#region src/traversable/KVTraversable.d.ts
/**
 * A traversable interface for key-value containers that excludes map, flatMap,
 * flatMapAsync, and ap operations.
 *
 * Key-value containers (Map, Obj) cannot satisfy Functor's unconstrained
 * `map<B extends Type>` because their type parameter is constrained
 * (e.g., to Record or Tuple pairs). These containers redefine map/flatMap
 * with their own tighter constraints.
 *
 * @typeParam A - The element type of the traversable
 */
type KVTraversable<A> = Omit<Traversable<A>, "map" | "flatMap" | "flatMapAsync" | "ap">;
//#endregion
//#region src/map/Map.d.ts
interface Map$1<K, out V> extends KVTraversable<Tuple<[K, V]>>, Collection<Tuple<[K, V]>>, Typeable<"Map">, Serializable<[K, V][]>, Pipe<[K, V][]>, Foldable<Tuple<[K, V]>>, Iterable<[K, V]> {
  readonly [Symbol.toStringTag]: string;
  readonly _tag: "Map";
  add(item: Tuple<[K, V]>): Map$1<K, V>;
  remove(value: K): Map$1<K, V>;
  map<U>(f: (value: V) => U): Map$1<K, U>;
  ap<U>(ff: Map$1<K, (value: V) => U>): Map$1<K, U>;
  flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => Iterable<[K2, V2]>): Map$1<K2, V2>;
  flatMapAsync<U>(f: (value: V) => PromiseLike<Map$1<K, U>>): PromiseLike<Map$1<K, U>>;
  get(key: K): Option<V>;
  getOrElse(key: K, defaultValue: V): V;
  orElse(key: K, alternative: Option<V>): Option<V>;
  fold<B>(initial: B, fn: (acc: B, a: Tuple<[K, V]>) => B): B;
  foldLeft<B>(z: B): (op: (b: B, a: Tuple<[K, V]>) => B) => B;
  foldRight<B>(z: B): (op: (a: Tuple<[K, V]>, b: B) => B) => B;
  /**
   * Pattern matches over the Map, applying a handler function based on whether it's empty
   * @param patterns - Object with handler functions for Empty and NonEmpty variants
   * @returns The result of applying the matching handler function
   */
  match<R>(patterns: {
    Empty: () => R;
    NonEmpty: (entries: Array<Tuple<[K, V]>>) => R;
  }): R;
  toValue(): {
    _tag: "Map";
    value: [K, V][];
  };
}
declare const Map$1: (<K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null) => Map$1<K, V>) & {
  /**
   * Creates an empty Map
   * Returns a singleton instance for efficiency
   * @returns An empty Map instance
   */
  empty: <K, V>() => Map$1<K, V>;
  /**
   * Creates a Map from variadic key-value pair arguments
   * @param entries - Key-value pairs to create map from
   * @returns A Map containing the entries
   */
  of: <K, V>(...entries: [K, V][]) => Map$1<K, V>;
  /**
   * Creates a Map from JSON string
   * @param json - The JSON string
   * @returns Map instance
   */
  fromJSON: <K, V>(json: string) => Map$1<K, V>;
  /**
   * Creates a Map from YAML string
   * @param yaml - The YAML string
   * @returns Map instance
   */
  fromYAML: <K, V>(yaml: string) => Map$1<K, V>;
  /**
   * Creates a Map from binary string
   * @param binary - The binary string
   * @returns Map instance
   */
  fromBinary: <K, V>(binary: string) => Map$1<K, V>;
};
//#endregion
//#region src/map/shim.d.ts
/**
 * Type alias for the native JavaScript Map
 * @interface
 * @module Map
 * @category Collections
 */
type ESMapType<K, V> = Map<K, V>;
/**
 * Reference to the native JavaScript Map
 * @module Map
 * @category Collections
 */
declare const ESMap: MapConstructor;
//#endregion
//#region src/obj/Obj.d.ts
/**
 * Obj type module
 * @module Obj
 * @category Core
 */
/**
 * The Obj type wraps a plain JavaScript object and provides fluent,
 * immutable operations for building and transforming objects.
 *
 * @typeParam T - The record type of the contained object
 *
 * @example
 * ```typescript
 * // Build HTTP headers immutably with conditional auth
 * const headers = Obj({ "User-Agent": userAgent })
 *   .assign(options.headers)
 *   .when(requiresAuth, { Authorization: `Bearer ${token}` })
 *   .value()
 *
 * // Fluent object construction
 * Obj.of({ name: "John" })
 *   .set("age", 31)
 *   .merge({ city: "NYC" })
 *   .value()
 * ```
 */
interface Obj<T extends Record<string, Type>> extends Omit<Functype<T, "Obj">, "map" | "flatMap" | "flatMapAsync" | "ap">, Promisable<T>, Doable<T>, Reshapeable<T> {
  /** The contained object value */
  readonly data: T;
  /**
   * Maps the contained object to a new object using the provided function
   * @param f - The mapping function (must return a Record)
   * @returns A new Obj containing the mapped value
   */
  map<U extends Record<string, Type>>(f: (value: T) => U): Obj<U>;
  /**
   * FlatMaps the contained object using a function that returns an Obj
   * @param f - The flatMap function
   * @returns The Obj returned by f
   */
  flatMap<U extends Record<string, Type>>(f: (value: T) => Obj<U>): Obj<U>;
  /**
   * Async flatMap for the contained object
   * @param f - The async flatMap function
   * @returns A Promise of the Obj returned by f
   */
  flatMapAsync<U extends Record<string, Type>>(f: (value: T) => PromiseLike<Obj<U>>): PromiseLike<Obj<U>>;
  /**
   * Applies a wrapped function to the contained object
   * @param ff - An Obj containing a function from T to U
   * @returns A new Obj containing the result
   */
  ap<U extends Record<string, Type>>(ff: Obj<Record<string, Type>>): Obj<U>;
  /**
   * Get a value by key, returning Option
   * @param key - The key to look up
   * @returns Option containing the value if present
   */
  get<K extends keyof T>(key: K): Option<T[K]>;
  /**
   * Set a single key to a new value, returning a new Obj
   * @param key - The key to set (must exist in T)
   * @param value - The value to set
   * @returns A new Obj with the updated key
   */
  set<K extends keyof T>(key: K, value: T[K]): Obj<T>;
  /**
   * Merge a partial of the same shape (no new keys)
   * @param partial - Partial object to merge
   * @returns A new Obj with merged values
   */
  assign(partial: Partial<T>): Obj<T>;
  /**
   * Merge with a potentially wider type (can add new keys)
   * @param other - Object to merge in
   * @returns A new Obj with the merged type
   */
  merge<U extends Record<string, Type>>(other: U): Obj<T & U>;
  /**
   * Conditionally merge a partial based on a boolean or predicate
   * @param condition - Boolean or predicate function
   * @param partial - Partial to merge if condition is true
   * @returns A new Obj, with or without the merge applied
   */
  when(condition: boolean | (() => boolean), partial: Partial<T>): Obj<T>;
  /**
   * Return a new Obj without the specified keys
   * @param keys - Keys to remove
   * @returns A new Obj without the specified keys
   */
  omit<K extends keyof T>(...keys: K[]): Obj<Omit<T, K>>;
  /**
   * Return a new Obj with only the specified keys
   * @param keys - Keys to keep
   * @returns A new Obj with only the specified keys
   */
  pick<K extends keyof T>(...keys: K[]): Obj<Pick<T, K>>;
  /**
   * Return a List of keys
   * @returns List of string keys
   */
  keys(): List<string>;
  /**
   * Return a List of values
   * @returns List of values
   */
  values(): List<T[keyof T]>;
  /**
   * Return a List of [key, value] Tuples
   * @returns List of key-value Tuples
   */
  entries(): List<ReturnType<typeof Tuple<[string, T[keyof T]]>>>;
  /**
   * Unwrap to the plain object
   * @returns The contained plain object
   */
  value(): T;
  /**
   * Check if a key exists
   * @param key - The key to check
   * @returns true if the key exists
   */
  has<K extends keyof T>(key: K): boolean;
  /**
   * Pattern match fold — applies onEmpty if empty, onValue if non-empty
   * @param onEmpty - Handler for empty Obj
   * @param onValue - Handler for non-empty Obj
   * @returns The result of the matching handler
   */
  fold<U extends Type>(onEmpty: () => U, onValue: (value: T) => U): U;
  /**
   * Returns a string representation of this Obj
   * @returns A string representation
   */
  toString(): string;
}
/**
 * Obj - Immutable object wrapper with fluent operations.
 *
 * Wraps plain JavaScript objects and provides chainable, immutable
 * operations for building and transforming them. Implements the full
 * Functype interface (Functor, Foldable, Serializable, Matchable, etc.).
 *
 * @example
 * ```typescript
 * // Build headers with conditional auth
 * const headers = Obj({ "User-Agent": "MyApp/1.0" })
 *   .assign(options.headers)
 *   .when(requiresAuth, { Authorization: `Bearer ${token}` })
 *   .value()
 *
 * // Object manipulation
 * const user = Obj({ name: "John", age: 30, role: "admin" })
 * user.pick("name", "role").value()  // { name: "John", role: "admin" }
 * user.omit("role").value()          // { name: "John", age: 30 }
 * user.get("name")                   // Some("John")
 * ```
 */
declare const Obj: (<T extends Record<string, Type>>(data: T) => Obj<T>) & {
  /**
   * Creates an Obj from a plain object. Alias for Obj().
   * @param data - The plain object to wrap
   * @returns A new Obj instance
   */
  of: <T extends Record<string, Type>>(data: T) => Obj<T>;
  /**
   * Creates an empty Obj.
   * @returns An empty Obj instance
   */
  empty: <T extends Record<string, Type>>() => Obj<T>;
  /**
   * Deserializes an Obj from a JSON string.
   * @param json - The JSON string to parse
   * @returns A new Obj instance
   */
  fromJSON: <T extends Record<string, Type>>(json: string) => Obj<T>;
  /**
   * Deserializes an Obj from a base64-encoded binary string.
   * @param binary - The base64 string to decode
   * @returns A new Obj instance
   */
  fromBinary: <T extends Record<string, Type>>(binary: string) => Obj<T>;
};
//#endregion
//#region src/ref/Ref.d.ts
/**
 * A mutable reference container that holds a value of type A.
 * This provides controlled mutability in a functional context.
 *
 * **Variance: invariant in A by design.** Ref is a mutable cell — `set(A)`
 * writes A (contravariant) and `get(): A` reads A (covariant), so A is
 * genuinely invariant. Unlike the other containers in functype, Ref has no
 * `<out A>` annotation and cannot be widened via subtyping. This mirrors
 * Scala's `scala.concurrent.stm.Ref` and reflects the fundamental nature of
 * mutable state: you can't safely treat a `Ref[Narrow]` as a `Ref[Wide]`
 * because someone could `set` a Wide value that isn't a Narrow.
 *
 * @example
 * const counter = Ref(0)
 * counter.get() // 0
 * counter.set(5)
 * counter.get() // 5
 * counter.update(n => n + 1)
 * counter.get() // 6
 */
interface Ref<A> {
  /**
   * Get the current value
   */
  get(): A;
  /**
   * Set a new value
   */
  set(value: A): void;
  /**
   * Update the value using a function
   */
  update(f: (current: A) => A): void;
  /**
   * Update and return the old value
   */
  getAndSet(value: A): A;
  /**
   * Update and return the new value
   */
  updateAndGet(f: (current: A) => A): A;
  /**
   * Update and return the old value
   */
  getAndUpdate(f: (current: A) => A): A;
  /**
   * Compare and swap - only updates if current value equals expected
   */
  compareAndSet(expected: A, newValue: A): boolean;
  /**
   * Modify the value and return a result
   */
  modify<B>(f: (current: A) => [A, B]): B;
}
declare const Ref: (<A extends Type>(initial: A) => Ref<A>) & {
  /**
   * Creates a Ref. Alias for Ref constructor.
   * @param initial - The initial value
   * @returns Ref instance
   */
  of: <A extends Type>(initial: A) => Ref<A>;
};
//#endregion
//#region src/valuable/Valuable.d.ts
/**
 * Parameters for creating a Valuable instance
 */
type ValuableParams<Tag extends string, T, V> = {
  _tag: Tag;
  impl: T;
  value: V;
};
/**
 * Represents a type that can extract its inner value. Creates a Valuable wrapper that adds value extraction capabilities.
 * @param params - Configuration parameters
 * @module Valuable
 * @category Utilities
 */
declare function Valuable<Tag extends string, V, T = object>(params: ValuableParams<Tag, T, V>): T & {
  toValue: () => {
    _tag: Tag;
    value: V;
  };
  _tag: Tag;
};
type Valuable<Tag extends string, V, T = object> = Typeable<Tag, T> & {
  toValue: () => {
    _tag: Tag;
    value: V;
  };
};
//#endregion
//#region src/stack/Stack.d.ts
/**
 * Stack data structure - Last In, First Out (LIFO)
 * Implements the Traversable interface for working with ordered collections
 */
type Stack<A extends Type> = {
  readonly [Symbol.toStringTag]: string;
  /**
   * Push a value onto the top of the stack. The value may be a wider type;
   * the result widens to `Stack<A | B>` (Scala: `:+[B >: A]`).
   * @param value - The value to push
   * @returns A new Stack with the value added
   */
  push<B extends Type>(value: B): Stack<A | B>;
  /**
   * Remove and return the top value from the stack
   * @returns A tuple containing the new Stack and the value
   */
  pop(): [Stack<A>, Option<A>];
  /**
   * Return the top value without removing it
   * @returns The top value wrapped in an Option
   */
  peek(): Option<A>;
  /**
   * Transforms each element in the stack using the provided function
   * @param f - The mapping function
   * @returns A new Stack with transformed elements
   */
  map<B extends Type>(f: (a: A) => B): Stack<B>;
  /**
   * Maps each element to a Stack and flattens the result
   * @param f - The mapping function returning a Stack
   * @returns A new flattened Stack
   */
  flatMap<B extends Type>(f: (a: A) => Stack<B>): Stack<B>;
  /**
   * Applies a Stack of functions to this Stack
   * @param ff - Stack of functions to apply
   * @returns A new Stack with applied functions
   */
  ap<B extends Type>(ff: Stack<(value: A) => B>): Stack<B>;
  /**
   * Maps each element to an async Stack and flattens the result
   * @param f - The async mapping function returning a Stack
   * @returns A promise of the new flattened Stack
   */
  flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Stack<B>>): PromiseLike<Stack<B>>;
  /**
   * Convert the stack to a List
   * @returns A List containing all elements
   */
  toList(): List<A>;
  /**
   * Convert the stack to an array
   * @returns An array of all elements
   */
  toArray(): A[];
  /**
   * Returns a string representation of the stack
   * @returns A string representation
   */
  toString(): string;
  /**
   * Left-associative fold over all elements using an initial value and combining function.
   */
  fold<B>(initial: B, fn: (acc: B, a: A) => B): B;
  /**
   * Pattern matches over the Stack, applying a handler function based on whether it's empty
   * @param patterns - Object with handler functions for Empty and NonEmpty variants
   * @returns The result of applying the matching handler function
   */
  match<R>(patterns: {
    Empty: () => R;
    NonEmpty: (values: A[]) => R;
  }): R;
} & Traversable<A> & Valuable<"Stack", A[]> & Serializable<A> & Pipe<A[]> & Foldable<A> & Matchable<A[], "Empty" | "NonEmpty">;
declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
  /**
   * Creates an empty stack
   * @returns An empty Stack instance
   */
  empty: <A extends Type>() => Stack<A>;
  /**
   * Creates a Stack from a single value
   * @param value - The value to create a stack with
   * @returns A Stack with a single value
   */
  of: <A extends Type>(value: A) => Stack<A>;
  /**
   * Creates a Stack from JSON string
   * @param json - The JSON string
   * @returns Stack instance
   */
  fromJSON: <A>(json: string) => Stack<A>;
  /**
   * Creates a Stack from YAML string
   * @param yaml - The YAML string
   * @returns Stack instance
   */
  fromYAML: <A>(yaml: string) => Stack<A>;
  /**
   * Creates a Stack from binary string
   * @param binary - The binary string
   * @returns Stack instance
   */
  fromBinary: <A>(binary: string) => Stack<A>;
};
//#endregion
//#region src/option/Option.d.ts
/**
 * Option type module
 * @module Option
 * @category Core
 */
/**
 * The Option type represents a value that may or may not exist.
 * It's used to handle potentially null or undefined values in a type-safe way.
 * @typeParam T - The type of the value contained in the Option
 */
interface Option<out 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. The default may be of a
   * different type; the result widens to `T | T2` so Option stays covariant in T.
   * @param defaultValue - The value to return if this Option is None
   * @returns The contained value or defaultValue, typed as `T | T2`
   */
  orElse<T2 extends Type>(defaultValue: T2): T | T2;
  /**
   * 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 the contained value, or calls the never-returning handler if None.
   * Use this when you have a helper like `(msg) => fail(msg, 2)` that terminates the
   * program — the result type is unconditionally `T`, so you avoid the TypeScript
   * narrowing trap where `if (o.isNone()) fail(...)` fails to narrow `o.value` when
   * `fail` is an arrow function typed as `(...): never`.
   */
  expect(handler: () => never): T;
  /**
   * Returns this Option if it contains a value, otherwise returns the alternative container.
   * The alternative may hold a different type; the result widens to `Option<T | T2>`.
   * @param alternative - The alternative Option to return if this is None
   * @returns This Option or the alternative, typed as `Option<T | T2>`
   */
  or<T2 extends Type>(alternative: Option<T2>): Option<T | T2>;
  /**
   * 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>>;
  /**
   * 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;
  /**
   * Async variant of fold. Accepts sync or async handlers on either branch and
   * always returns a Promise.
   */
  foldAsync<U>(onNone: () => U | Promise<U>, onSome: (value: T) => U | Promise<U>): Promise<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;
  /**
   * 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;
  /**
   * Converts this Option to a List.
   * @returns A List containing the value if Some, or empty List if None
   */
  toList(): List<T>;
  /**
   * Converts this Option to a plain readonly array.
   * @returns `[value]` if Some, `[]` if None. Symmetric with `toList()` but
   *   skips the List wrapper for code that just wants Array-prototype methods
   *   or spread into another array.
   */
  toArray(): readonly T[];
  /** The number of elements in this Option (0 or 1) */
  size: number;
  /**
   * Converts this Option to an Either
   * @param leftOrBuilder - The Left value to use if None, or a thunk producing it.
   *   Pass a thunk when the Left value is expensive to construct or carries
   *   context (e.g. `() => ConfigError(missing)`) so the cost is paid only
   *   on the None path. Eager value is fine for cheap errors.
   * @returns Right(value) if Some, else Left(leftOrBuilder()) / Left(leftOrBuilder)
   */
  toEither<E>(leftOrBuilder: E | (() => 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;
  };
  /**
   * Custom JSON serialization producing the canonical `@functype`-marked
   * envelope so native `JSON.stringify` recursion (e.g. inside a plain
   * object) emits a round-trip-able shape.
   */
  toJSON(): {
    "@functype": "Option";
    _tag: "Some" | "None";
    value: T | null;
  };
  /**
   * Pattern matches over the Option, applying a handler function based on the variant
   * @param patterns - Object with handler functions for Some and None variants
   * @returns The result of applying the matching handler function
   */
  match<R>(patterns: {
    Some: (value: T) => R;
    None: () => R;
  }): R;
}
/**
 * Creates a Some variant of Option containing a value.
 * @param value - The value to wrap in Some
 * @returns A new Some instance containing the value
 * @typeParam T - The type of the value
 */
declare const Some: <T extends Type>(value: T) => Option<T>;
/**
 * Creates a None variant of Option representing absence of a value.
 * @returns A new None instance
 * @typeParam T - The type that would be contained if this was a Some
 */
declare const None: <T extends Type>() => Option<T>;
/**
 * Safely wraps a value that might be null or undefined in an Option.
 * Creates Some if the value is defined, None otherwise.
 * @param value - The value to wrap (might be null/undefined)
 * @returns Some(value) if value is defined, None otherwise
 * @typeParam T - The type of the value
 */
declare const OptionConstructor: <T extends Type>(value: T | null | undefined) => Option<T>;
declare const Option: (<T extends Type>(value: T | null | undefined) => Option<T>) & {
  /**
   * Creates an Option from any value. Alias for Option function.
   * @param value - The value to wrap
   * @returns Some(value) if value is defined, None otherwise
   * @typeParam T - The type of the value
   */
  from: <T>(value: T) => Option<T>;
  /**
   * Returns a None instance. Alias for None function.
   * @returns A None instance
   * @typeParam T - The type that would be contained if this was a Some
   */
  none: <T>() => Option<T>;
  /**
   * Type guard to check if an Option is Some
   * @param option - The Option to check
   * @returns True if Option is Some
   */
  isSome: <T>(option: Option<T>) => option is Option<T> & {
    value: T;
    isEmpty: false;
  };
  /**
   * Type guard to check if an Option is None
   * @param option - The Option to check
   * @returns True if Option is None
   */
  isNone: <T>(option: Option<T>) => option is Option<T> & {
    value: undefined;
    isEmpty: true;
  };
  /**
   * Creates an Option from JSON string
   * @param json - The JSON string
   * @returns Option instance
   */
  fromJSON: <T>(json: string) => Option<T>;
  /**
   * Creates an Option from YAML string
   * @param yaml - The YAML string
   * @returns Option instance
   */
  fromYAML: <T>(yaml: string) => Option<T>;
  /**
   * Creates an Option from binary string
   * @param binary - The binary string
   * @returns Option instance
   */
  fromBinary: <T>(binary: string) => Option<T>;
  /**
   * Combines an array of Options into a single Option containing an array.
   * Short-circuits on the first None.
   * @param options - Array of Option values
   * @returns Some with array of values, or None if any element is None
   */
  sequence: <T extends Type>(options: Option<T>[]) => Option<T[]>;
  /**
   * Maps an array through a function returning Option, then sequences the results.
   * Short-circuits on the first None — `f` is not invoked for elements after the
   * first None result.
   * @param arr - Array of values
   * @param f - Function returning Option
   * @returns Some with array of mapped values, or None if any application returned None
   */
  traverse: <T extends Type, U extends Type>(arr: ReadonlyArray<T>, f: (value: T, index: number) => Option<U>) => Option<U[]>;
};
//#endregion
//#region src/conditional/Match.d.ts
/**
 * Type-level utilities for exhaustiveness checking
 * @internal
 */
type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
/** @internal */
type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
/** @internal */
type RequireExhaustive<T, Cases> = IsUnion<T> extends true ? (keyof Cases extends T ? (T extends keyof Cases ? Cases : never) : never) : Cases;
/**
 * Pattern types for nested matching
 * @internal
 */
type Pattern<T> = T | { [K in keyof T]?: Pattern<T[K]>; } | ((value: T) => boolean) | {
  _: (value: T) => boolean;
};
/**
 * Extract result from pattern
 * @internal
 */
type PatternResult<T, R> = R | ((matched: T) => R);
/**
 * Untyped Match (before first case is added).
 * The result type R is inferred when the first case method is called.
 * This enables proper type inference without requiring explicit type annotations.
 *
 * @internal
 */
type UntypedMatch<T extends Type> = {
  /**
   * Match against a pattern - infers result type R from the result parameter
   */
  case: <R extends Type>(pattern: Pattern<T>, result: PatternResult<T, R>) => Match<T, R>;
  /**
   * Match a specific value - infers result type R from the result parameter
   */
  caseValue: <R extends Type>(match: T, result: R | (() => R)) => Match<T, R>;
  /**
   * Match multiple values - infers result type R from the result parameter
   */
  caseValues: <R extends Type>(matches: T[], result: R | (() => R)) => Match<T, R>;
  /**
   * Match with a guard function - infers result type R from the result parameter
   */
  when: <R extends Type>(guard: (value: T) => boolean, result: PatternResult<T, R>) => Match<T, R>;
  /**
   * Match multiple patterns (OR operation) - infers result type R from the result parameter
   */
  caseAny: <R extends Type>(patterns: Pattern<T>[], result: PatternResult<T, R>) => Match<T, R>;
};
/**
 * Pattern matching construct similar to Scala's match expressions.
 * Supports exhaustive matching, nested patterns, and guards.
 *
 * @example
 * // Basic pattern matching
 * const result = Match(value)
 *   .case(x => x > 100, "large")
 *   .case(x => x > 50, "medium")
 *   .default("small")
 *
 * @example
 * // Matching exact values
 * const message = Match(status)
 *   .caseValue("pending", "Please wait...")
 *   .caseValue("success", "Completed!")
 *   .caseValue("error", "Failed")
 *   .default("Unknown")
 *
 * @example
 * // Nested pattern matching
 * const user = { name: "John", age: 30, role: "admin" }
 * const msg = Match(user)
 *   .case({ role: "admin", age: n => n >= 18 }, "Adult admin")
 *   .case({ role: "user" }, u => `User: ${u.name}`)
 *   .default("Guest")
 */
type Match<T extends Type, R extends Type> = {
  /**
   * Match against a pattern (value, nested object, or predicate).
   * The result type R2 is added to the union of possible results.
   */
  case: <R2 extends Type>(pattern: Pattern<T>, result: PatternResult<T, R2>) => Match<T, R | R2>;
  /**
   * Add a case that matches a specific value.
   * The result type R2 is added to the union of possible results.
   */
  caseValue: <R2 extends Type>(match: T, result: R2 | (() => R2)) => Match<T, R | R2>;
  /**
   * Add a case that matches multiple values.
   * The result type R2 is added to the union of possible results.
   */
  caseValues: <R2 extends Type>(matches: T[], result: R2 | (() => R2)) => Match<T, R | R2>;
  /**
   * Match with a guard function (alias for readability).
   * The result type R2 is added to the union of possible results.
   */
  when: <R2 extends Type>(guard: (value: T) => boolean, result: PatternResult<T, R2>) => Match<T, R | R2>;
  /**
   * Match multiple patterns (OR operation).
   * The result type R2 is added to the union of possible results.
   */
  caseAny: <R2 extends Type>(patterns: Pattern<T>[], result: PatternResult<T, R2>) => Match<T, R | R2>;
  /**
   * Default case - makes match non-exhaustive.
   * The result type R2 is added to the union of possible results.
   */
  default: <R2 extends Type>(result: PatternResult<T, R2>) => R | R2;
  /**
   * Force exhaustive matching (compile-time check for union types)
   */
  exhaustive: () => R;
  /**
   * Get result if matched, throws if no match
   */
  orThrow: (errorMessage?: string) => R;
  /**
   * Get result wrapped in Option
   */
  toOption: () => Option<R>;
};
/**
 * Pattern matching utility for type-safe conditional logic with exhaustiveness checking,
 * nested patterns, and guard support
 *
 * @example
 * // Basic pattern matching
 * const result = Match(value)
 *   .case(x => x > 0, "positive")
 *   .case(x => x < 0, "negative")
 *   .default("zero")
 *
 * @example
 * // Exhaustive matching for union types
 * type Color = "red" | "green" | "blue"
 * const hex = Match.exhaustive<Color, string>({
 *   red: "#FF0000",
 *   green: "#00FF00",
 *   blue: "#0000FF"
 * })(color)
 *
 * @example
 * // Nested pattern matching
 * type User = { name: string; age: number; role: "admin" | "user" }
 * const user: User = { name: "John", age: 30, role: "admin" }
 *
 * const message = Match<User, string>(user)
 *   .case({ role: "admin", age: (n) => n >= 18 }, "Adult admin")
 *   .case({ role: "user" }, u => `User: ${u.name}`)
 *   .default("Unknown")
 *
 * @example
 * // Using exhaustive() method
 * type Status = "idle" | "loading" | "success" | "error"
 * const result = Match<Status, string>("success")
 *   .case("idle", "Waiting...")
 *   .case("loading", "Loading...")
 *   .case("success", "Done!")
 *   .case("error", "Failed!")
 *   .exhaustive()
 */
declare const Match: (<T extends Type>(value: T) => UntypedMatch<T>) & {
  /**
   * Create a type-safe exhaustive match for union types
   * @example
   * type Status = "pending" | "success" | "error"
   * const status: Status = "success"
   * const result = Match.exhaustive<Status, string>({
   *   pending: "Waiting...",
   *   success: "Done!",
   *   error: "Failed!"
   * })(status)
   * // result = "Done!"
   *
   * @example
   * // For function values, wrap in object to prevent execution
   * type Operation = "add" | "subtract" | "multiply"
   * const ops = Match.exhaustive<Operation, { fn: (a: number, b: number) => number }>({
   *   add: { fn: (a, b) => a + b },
   *   subtract: { fn: (a, b) => a - b },
   *   multiply: { fn: (a, b) => a * b }
   * })
   * const compute = ops("multiply").fn
   * const result = compute(4, 5) // 20
   */
  exhaustive: <T extends string | number | symbol, R extends Type>(cases: RequireExhaustive<T, Record<T, R>>) => (value: T) => R;
  /**
   * Create a partial match that requires a default
   * @example
   * const httpCode = 404
   * const message = Match.partial<number, string>({
   *   200: "OK",
   *   201: "Created",
   *   404: "Not Found",
   *   500: "Server Error"
   * }).withDefault("Unknown Status")(httpCode)
   * // message = "Not Found"
   *
   * @example
   * // With function default
   * const getMessage = Match.partial<number, string>({
   *   0: "Zero",
   *   1: "One",
   *   2: "Two"
   * }).withDefault((n) => `Number: ${n}`)
   * getMessage(5) // "Number: 5"
   */
  partial: <T extends string | number | symbol, R extends Type>(cases: Partial<Record<T, R | ((value: T) => R)>>) => {
    withDefault: (defaultValue: R | ((value: T) => R)) => (value: T) => R;
  };
  /**
   * Pattern match with guards
   * @example
   * const score = 85
   * const grade = Match.withGuards<number, string>([
   *   [n => n >= 90, "A"],
   *   [n => n >= 80, "B"],
   *   [n => n >= 70, "C"],
   *   [n => n >= 60, "D"]
   * ]).withDefault("F")(score)
   * // grade = "B"
   *
   * @example
   * // With function results for custom messages
   * const age = 25
   * const category = Match.withGuards<number, string>([
   *   [n => n < 13, n => `Child (${n} years)`],
   *   [n => n < 20, n => `Teenager (${n} years)`],
   *   [n => n < 60, n => `Adult (${n} years)`],
   *   [n => n >= 60, n => `Senior (${n} years)`]
   * ]).withDefault("Unknown")(age)
   * // category = "Adult (25 years)"
   */
  withGuards: <T extends Type, R extends Type>(guards: Array<[(value: T) => boolean, R | ((value: T) => R)]>) => {
    withDefault: (defaultValue: R | ((value: T) => R)) => (value: T) => R;
  };
  /**
   * Pattern matching for objects with specific structure
   * @example
   * type Event =
   *   | { type: "click"; x: number; y: number }
   *   | { type: "keypress"; key: string }
   *   | { type: "hover"; element: string }
   *
   * const handler = Match.struct<Event, void>()
   *   .case({ type: "click" }, (e) => console.log(`Click at ${e.x}, ${e.y}`))
   *   .case({ type: "keypress", key: "Enter" }, () => console.log("Enter pressed"))
   *   .case({ type: "hover" }, (e) => console.log(`Hovering over ${e.element}`))
   *   .build()
   */
  struct: <T extends Type, R extends Type>() => {
    case: (pattern: Pattern<T>, handler: (value: T) => R) => /*elided*/ any;
    build: () => (value: T) => R;
  };
  /**
   * Create a pattern matcher with guards and nested patterns
   * @example
   * type User = {
   *   name: string
   *   age: number
   *   permissions: string[]
   * }
   *
   * const canAccess = Match.builder<User, boolean>()
   *   .when(u => u.permissions.includes("admin"), true)
   *   .case({ age: n => n >= 18, permissions: p => p.length > 0 }, true)
   *   .default(false)
   *   .build()
   */
  builder: <T extends Type, R extends Type>() => {
    case: (pattern: Pattern<T>, result: PatternResult<T, R>) => /*elided*/ any;
    when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => /*elided*/ any;
    default: (result: PatternResult<T, R>) => {
      build: () => (value: T) => R;
    };
  };
};
//#endregion
export { LayerError as $, Either as $n, TaskOutcome as $t, HttpQueryParams as A, Collection as An, DoGenerator as At, ResponseDecodeError as B, createCustomSerializer as Bn, DecoderError as Bt, TryKind as C, FunctypeSum as Cn, isExtractable as Cr, createErrorSerializer as Ct, HttpClient as D, Traversable as Dn, Cond as Dr, $ as Dt, Http as E, FunctypeCollection as En, Doable as Er, safeStringify as Et, DecodeError as F, JSONValue as Fn, LeftErrorType as Ft, InterruptedError as G, fromBinary as Gn, CancellationTokenSource as Gt, TestClockTag as H, createSerializer as Hn, DecoderErrorLeaf as Ht, HttpError as I, Serialization_d_exports as In, NoneError as It, Task as J, taggedEnvelope as Jn, Sync as Jt, RIO as K, fromJSON as Kn, Err as Kt, HttpMethod as L, FUNCTYPE_MARKER as Ln, isDoCapable as Lt, HttpRequestView as M, List as Mn, FailureError as Mt, HttpResponse as N, Try as Nn, FailureErrorType as Nt, HttpClientConfig as O, Matchable as On, Do as Ot, ParseMode as P, TypeNames as Pn, LeftError as Pt, Layer as Q, LazyList as Qn, TaskMetadata as Qt, HttpStatusError as R, FunctypeEnvelope as Rn, unwrap as Rt, OptionKind as S, ValidatedBrandCompanion as Sn, Extractable as Sr, TaskErrorInfo as St, FoldableUtils as T, FunctypeBase as Tn, DoResult as Tr, formatStackTrace as Tt, TestContext as U, createTaggedSerializer as Un, Async as Ut, TestClock as V, createSerializationCompanion as Vn, DecoderErrorComposite as Vt, IO as W, envelope as Wn, CancellationToken as Wt, UIO as X, deserializeError as Xn, Task$1 as Xt, TimeoutError as Y, SerializedError as Yn, TaggedThrowable as Yt, UnsupportedSyncOperationError as Z, serializeError as Zn, TaskFailure as Zt, Identity as _, PositiveInteger as _n, AsyncMonad as _r, TypedError as _t, OptionConstructor as a, NAME as an, TestEither as ar, ContextServices as at, Kind as b, UrlString as bn, CollectionOps as br, ErrorFormatterOptions as bt, Valuable as c, Base as cn, isLeft as cr, TagService as ct, Obj as d, EmailAddress as dn, tryCatchAsync as dr, Validation as dt, TaskParams as en, EitherBase as er, LayerInput as et, ESMap as f, ISO8601Date as fn, Widen as fr, ValidationRule as ft, Lazy as g, PatternString as gn, Applicative as gr, ErrorStatus as gt, KVTraversable as h, NonNegativeNumber as hn, Promisable as hr, ErrorMessage as ht, Option as i, isTaggedThrowable as in, RightOf as ir, Context as it, HttpRequestOptions as j, Set as jn, EmptyListError as jt, HttpMethodOptions as k, MatchableUtils as kn, DoAsync as kt, ValuableParams as l, BoundedNumber as ln, isRight as lr, FieldValidation as lt, Map$1 as m, NonEmptyString as mn, reduceWiden as mr, ErrorCode as mt, UntypedMatch as n, TaskSuccess as nn, LeftOf as nr, Exit as nt, Some as o, Throwable as on, TypeCheckLeft as or, HasService as ot, ESMapType as p, IntegerNumber as pn, reduceRightWiden as pr, Validator as pt, RepeatExhausted as q, fromYAML as qn, Ok as qt, None as r, createCancellationTokenSource as rn, Right as rr, ExitTag as rt, Stack as s, ThrowableType as sn, TypeCheckRight as sr, Tag as st, Match as t, TaskResult as tn, Left as tr, LayerOutput as tt, Ref as u, BoundedString as un, tryCatch as ur, FormValidation as ut, EitherKind as v, PositiveNumber as vn, Functor as vr, TypedErrorContext as vt, UniversalContainer as w, Functype as wn, ParseError as wr, formatError as wt, ListKind as x, ValidatedBrand as xn, ContainerOps as xr, ErrorWithTaskInfo as xt, HKT as y, UUID as yn, Monad as yr, ErrorChainElement as yt, NetworkError as z, SerializationResult as zn, Decoder as zt };