@nlozgachev/pipelined 0.12.0 → 0.13.0

package/dist/core.d.mts

@@ -0,0 +1,2170 @@
+import { O as Option, W as WithValue, a as WithLog, R as Result, b as WithKind, c as WithError, T as Task, d as WithErrors, e as WithFirst, f as WithSecond } from './Task-ChKyH0pF.mjs';
+export { D as Deferred, E as Err, N as None, g as Ok, S as Some } from './Task-ChKyH0pF.mjs';
+import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
+
+/** Keys of T for which undefined is assignable (i.e. optional fields). */
+type OptionalKeys<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? K : never;
+}[keyof T];
+/**
+ * Optional<S, A> focuses on a value A inside a structure S that may or may
+ * not be present. Like a Lens, but get returns Option<A>.
+ *
+ * Compose with other Optionals via `andThen`, or with a Lens via `andThenLens`.
+ * Convert a Lens to an Optional with `Lens.toOptional`.
+ *
+ * @example
+ * ```ts
+ * type Profile = { username: string; bio?: string };
+ *
+ * const bioOpt = Optional.prop<Profile>()("bio");
+ *
+ * pipe(profile, Optional.get(bioOpt));               // Some("hello") or None
+ * pipe(profile, Optional.set(bioOpt)("hello"));      // new Profile with bio set
+ * pipe(profile, Optional.modify(bioOpt)(s => s + "!")); // appends if present
+ * ```
+ */
+type Optional<S, A> = {
+    readonly get: (s: S) => Option<A>;
+    readonly set: (a: A) => (s: S) => S;
+};
+declare namespace Optional {
+    /**
+     * Constructs an Optional from a getter (returning Option<A>) and a setter.
+     *
+     * @example
+     * ```ts
+     * const firstChar = Optional.make(
+     *   (s: string) => s.length > 0 ? Option.some(s[0]) : Option.none(),
+     *   (c) => (s) => s.length > 0 ? c + s.slice(1) : s,
+     * );
+     * ```
+     */
+    const make: <S, A>(get: (s: S) => Option<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
+    /**
+     * Creates an Optional that focuses on an optional property of an object.
+     * Only keys whose type includes undefined (i.e. `field?: T`) are accepted.
+     * Call with the structure type first, then the key.
+     *
+     * @example
+     * ```ts
+     * type Profile = { username: string; bio?: string };
+     * const bioOpt = Optional.prop<Profile>()("bio");
+     * ```
+     */
+    const prop: <S>() => <K extends OptionalKeys<S>>(key: K) => Optional<S, NonNullable<S[K]>>;
+    /**
+     * Creates an Optional that focuses on an element at a given index in an array.
+     * Returns None when the index is out of bounds; set is a no-op when out of bounds.
+     *
+     * @example
+     * ```ts
+     * const firstItem = Optional.index<string>(0);
+     *
+     * pipe(["a", "b"], Optional.get(firstItem)); // Some("a")
+     * pipe([], Optional.get(firstItem));         // None
+     * ```
+     */
+    const index: <A>(i: number) => Optional<A[], A>;
+    /**
+     * Reads the focused value from a structure, returning Option<A>.
+     *
+     * @example
+     * ```ts
+     * pipe(profile, Optional.get(bioOpt)); // Some("...") or None
+     * ```
+     */
+    const get: <S, A>(opt: Optional<S, A>) => (s: S) => Option<A>;
+    /**
+     * Replaces the focused value within a structure.
+     * For indexed focuses, this is a no-op when the index is out of bounds.
+     *
+     * @example
+     * ```ts
+     * pipe(profile, Optional.set(bioOpt)("hello"));
+     * ```
+     */
+    const set: <S, A>(opt: Optional<S, A>) => (a: A) => (s: S) => S;
+    /**
+     * Applies a function to the focused value if it is present; returns the
+     * structure unchanged if the focus is absent.
+     *
+     * @example
+     * ```ts
+     * pipe(profile, Optional.modify(bioOpt)(s => s.toUpperCase()));
+     * ```
+     */
+    const modify: <S, A>(opt: Optional<S, A>) => (f: (a: A) => A) => (s: S) => S;
+    /**
+     * Returns the focused value or a default when the focus is absent.
+     *
+     * @example
+     * ```ts
+     * pipe(profile, Optional.getOrElse(bioOpt)(() => "no bio"));
+     * ```
+     */
+    const getOrElse: <S, A>(opt: Optional<S, A>) => (defaultValue: () => A) => (s: S) => A;
+    /**
+     * Extracts a value from an Optional focus using handlers for the present
+     * and absent cases.
+     *
+     * @example
+     * ```ts
+     * pipe(profile, Optional.fold(bioOpt)(() => "no bio", (bio) => bio.toUpperCase()));
+     * ```
+     */
+    const fold: <S, A>(opt: Optional<S, A>) => <B>(onNone: () => B, onSome: (a: A) => B) => (s: S) => B;
+    /**
+     * Pattern matches on an Optional focus using a named-case object.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   profile,
+     *   Optional.match(bioOpt)({ none: () => "no bio", some: (bio) => bio }),
+     * );
+     * ```
+     */
+    const match: <S, A>(opt: Optional<S, A>) => <B>(cases: {
+        none: () => B;
+        some: (a: A) => B;
+    }) => (s: S) => B;
+    /**
+     * Composes two Optionals: focuses through the outer, then through the inner.
+     * Returns None if either focus is absent.
+     *
+     * @example
+     * ```ts
+     * const deepOpt = pipe(
+     *   Optional.prop<User>()("address"),
+     *   Optional.andThen(Optional.prop<Address>()("landmark")),
+     * );
+     * ```
+     */
+    const andThen: <A, B>(inner: Optional<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
+    /**
+     * Composes an Optional with a Lens, producing an Optional.
+     * The Lens focuses within the value found by the Optional.
+     *
+     * @example
+     * ```ts
+     * const cityOpt = pipe(
+     *   Optional.prop<User>()("address"),
+     *   Optional.andThenLens(Lens.prop<Address>()("city")),
+     * );
+     * ```
+     */
+    const andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
+}
+
+/**
+ * Lens<S, A> focuses on a single value A inside a structure S, providing
+ * a composable way to read and immutably update nested data.
+ *
+ * A Lens always succeeds: the focused value is guaranteed to exist.
+ * For optional or indexed focuses, use Optional<S, A>.
+ *
+ * @example
+ * ```ts
+ * type Address = { city: string; zip: string };
+ * type User = { name: string; address: Address };
+ *
+ * const addressLens = Lens.prop<User>()("address");
+ * const cityLens    = Lens.prop<Address>()("city");
+ * const userCityLens = pipe(addressLens, Lens.andThen(cityLens));
+ *
+ * pipe(user, Lens.get(userCityLens));             // "Berlin"
+ * pipe(user, Lens.set(userCityLens)("Hamburg"));  // new User with city updated
+ * pipe(user, Lens.modify(userCityLens)(c => c.toUpperCase())); // "BERLIN"
+ * ```
+ */
+type Lens<S, A> = {
+    readonly get: (s: S) => A;
+    readonly set: (a: A) => (s: S) => S;
+};
+declare namespace Lens {
+    /**
+     * Constructs a Lens from a getter and a setter.
+     *
+     * @example
+     * ```ts
+     * const nameLens = Lens.make(
+     *   (user: User) => user.name,
+     *   (name) => (user) => ({ ...user, name }),
+     * );
+     * ```
+     */
+    const make: <S, A>(get: (s: S) => A, set: (a: A) => (s: S) => S) => Lens<S, A>;
+    /**
+     * Creates a Lens that focuses on a property of an object.
+     * Call with the structure type first, then the key.
+     *
+     * @example
+     * ```ts
+     * const nameLens = Lens.prop<User>()("name");
+     * ```
+     */
+    const prop: <S>() => <K extends keyof S>(key: K) => Lens<S, S[K]>;
+    /**
+     * Reads the focused value from a structure.
+     *
+     * @example
+     * ```ts
+     * pipe(user, Lens.get(nameLens)); // "Alice"
+     * ```
+     */
+    const get: <S, A>(lens: Lens<S, A>) => (s: S) => A;
+    /**
+     * Replaces the focused value within a structure, returning a new structure.
+     *
+     * @example
+     * ```ts
+     * pipe(user, Lens.set(nameLens)("Bob")); // new User with name "Bob"
+     * ```
+     */
+    const set: <S, A>(lens: Lens<S, A>) => (a: A) => (s: S) => S;
+    /**
+     * Applies a function to the focused value, returning a new structure.
+     *
+     * @example
+     * ```ts
+     * pipe(user, Lens.modify(nameLens)(n => n.toUpperCase())); // "ALICE"
+     * ```
+     */
+    const modify: <S, A>(lens: Lens<S, A>) => (f: (a: A) => A) => (s: S) => S;
+    /**
+     * Composes two Lenses: focuses through the outer, then through the inner.
+     * Use in a pipe chain to build up a deep focus step by step.
+     *
+     * @example
+     * ```ts
+     * const userCityLens = pipe(
+     *   Lens.prop<User>()("address"),
+     *   Lens.andThen(Lens.prop<Address>()("city")),
+     * );
+     * ```
+     */
+    const andThen: <A, B>(inner: Lens<A, B>) => <S>(outer: Lens<S, A>) => Lens<S, B>;
+    /**
+     * Composes a Lens with an Optional, producing an Optional.
+     * Use when the next step in the focus is optional (may be absent).
+     *
+     * @example
+     * ```ts
+     * const userBioOpt = pipe(
+     *   Lens.prop<User>()("profile"),
+     *   Lens.andThenOptional(Optional.prop<Profile>()("bio")),
+     * );
+     * ```
+     */
+    const andThenOptional: <A, B>(inner: Optional<A, B>) => <S>(outer: Lens<S, A>) => Optional<S, B>;
+    /**
+     * Converts a Lens to an Optional. Every Lens is a valid Optional
+     * whose get always returns Some.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Lens.prop<User>()("address"),
+     *   Lens.toOptional,
+     *   Optional.andThen(Optional.prop<Address>()("landmark")),
+     * );
+     * ```
+     */
+    const toOptional: <S, A>(lens: Lens<S, A>) => Optional<S, A>;
+}
+
+/**
+ * A value paired with an accumulated log.
+ *
+ * `Logged<W, A>` pairs a result `A` with a sequence of log entries `W`. When
+ * you sequence two `Logged` computations with `chain`, the logs are
+ * automatically concatenated — you never have to thread the log array through
+ * your code manually.
+ *
+ * @example
+ * ```ts
+ * const program = pipe(
+ *   Logged.make<string, number>(0),
+ *   Logged.chain(n => pipe(
+ *     Logged.tell("start"),
+ *     Logged.map(() => n + 1),
+ *   )),
+ *   Logged.chain(n => pipe(
+ *     Logged.tell("done"),
+ *     Logged.map(() => n * 10),
+ *   )),
+ * );
+ *
+ * Logged.run(program); // [10, ["start", "done"]]
+ * ```
+ */
+type Logged<L, A> = WithValue<A> & WithLog<L>;
+declare namespace Logged {
+    /**
+     * Wraps a pure value into a `Logged` with an empty log.
+     *
+     * @example
+     * ```ts
+     * Logged.make<string, number>(42); // { value: 42, log: [] }
+     * ```
+     */
+    const make: <W, A>(value: A) => Logged<W, A>;
+    /**
+     * Creates a `Logged` that records a single log entry and produces no
+     * meaningful value. Use this to append to the log inside a `chain`.
+     *
+     * @example
+     * ```ts
+     * Logged.tell("operation completed"); // { value: undefined, log: ["operation completed"] }
+     * ```
+     */
+    const tell: <W>(entry: W) => Logged<W, undefined>;
+    /**
+     * Transforms the value inside a `Logged` without affecting the log.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Logged.make<string, number>(5),
+     *   Logged.map(n => n * 2),
+     * ); // { value: 10, log: [] }
+     * ```
+     */
+    const map: <W, A, B>(f: (a: A) => B) => (data: Logged<W, A>) => Logged<W, B>;
+    /**
+     * Sequences two `Logged` computations, concatenating their logs.
+     * The value from the first is passed to `f`; the resulting log entries are
+     * appended after the entries from the first.
+     *
+     * Data-last — the first computation is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const result = pipe(
+     *   Logged.make<string, number>(1),
+     *   Logged.chain(n => pipe(Logged.tell("step"), Logged.map(() => n + 1))),
+     *   Logged.chain(n => pipe(Logged.tell("done"), Logged.map(() => n * 10))),
+     * );
+     *
+     * Logged.run(result); // [20, ["step", "done"]]
+     * ```
+     */
+    const chain: <W, A, B>(f: (a: A) => Logged<W, B>) => (data: Logged<W, A>) => Logged<W, B>;
+    /**
+     * Applies a function wrapped in a `Logged` to a value wrapped in a `Logged`,
+     * concatenating both logs.
+     *
+     * @example
+     * ```ts
+     * const fn: Logged<string, (n: number) => number> = {
+     *   value: n => n * 2,
+     *   log: ["fn-loaded"],
+     * };
+     * const arg: Logged<string, number> = { value: 5, log: ["arg-loaded"] };
+     *
+     * const result = pipe(fn, Logged.ap(arg));
+     * Logged.run(result); // [10, ["fn-loaded", "arg-loaded"]]
+     * ```
+     */
+    const ap: <W, A>(arg: Logged<W, A>) => <B>(data: Logged<W, (a: A) => B>) => Logged<W, B>;
+    /**
+     * Runs a side effect on the value without changing the `Logged`.
+     * Useful for debugging or inspecting intermediate values.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Logged.make<string, number>(42),
+     *   Logged.tap(n => console.log("value:", n)),
+     * );
+     * ```
+     */
+    const tap: <W, A>(f: (a: A) => void) => (data: Logged<W, A>) => Logged<W, A>;
+    /**
+     * Extracts the value and log as a `readonly [A, ReadonlyArray<W>]` tuple.
+     * Use this at the boundary where you need to consume both.
+     *
+     * @example
+     * ```ts
+     * const result = pipe(
+     *   Logged.make<string, number>(1),
+     *   Logged.chain(n => pipe(Logged.tell("incremented"), Logged.map(() => n + 1))),
+     * );
+     *
+     * const [value, log] = Logged.run(result);
+     * // value = 2, log = ["incremented"]
+     * ```
+     */
+    const run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
+}
+
+/**
+ * A function from `A` to `A is B` — a type predicate paired with a runtime check.
+ *
+ * A `Refinement<A, B>` proves at compile time that a value of type `A` is actually
+ * the narrower type `B extends A`, backed by a runtime boolean test. Use it to
+ * express domain invariants (non-empty strings, positive numbers, valid emails) as
+ * first-class, composable values rather than one-off type guards scattered across
+ * the codebase.
+ *
+ * @example
+ * ```ts
+ * type NonEmptyString = string & { readonly _tag: "NonEmptyString" };
+ *
+ * const isNonEmpty: Refinement<string, NonEmptyString> =
+ *   Refinement.make(s => s.length > 0);
+ *
+ * pipe(
+ *   "hello",
+ *   Refinement.toFilter(isNonEmpty)
+ * ); // Some("hello")
+ * ```
+ */
+type Refinement<A, B extends A> = (a: A) => a is B;
+declare namespace Refinement {
+    /**
+     * Creates a `Refinement<A, B>` from a plain boolean predicate.
+     *
+     * This is an unsafe cast — the caller is responsible for ensuring that the
+     * predicate truly characterises values of type `B`. Use this only when
+     * bootstrapping a new refinement; prefer `compose`, `and`, or `or` to build
+     * derived refinements from existing ones.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = number & { readonly _tag: "PositiveNumber" };
+     *
+     * const isPositive: Refinement<number, PositiveNumber> =
+     *   Refinement.make(n => n > 0);
+     * ```
+     */
+    const make: <A, B extends A>(f: (a: A) => boolean) => Refinement<A, B>;
+    /**
+     * Chains two refinements: if `ab` narrows `A` to `B` and `bc` narrows `B` to `C`,
+     * the result narrows `A` directly to `C`.
+     *
+     * Data-last — the first refinement `ab` is the data being piped.
+     *
+     * @example
+     * ```ts
+     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
+     * type TrimmedString  = NonEmptyString & { readonly _tag: "Trimmed" };
+     *
+     * const isNonEmpty: Refinement<string, NonEmptyString> =
+     *   Refinement.make(s => s.length > 0);
+     * const isTrimmed: Refinement<NonEmptyString, TrimmedString> =
+     *   Refinement.make(s => s === s.trim());
+     *
+     * const isNonEmptyTrimmed: Refinement<string, TrimmedString> = pipe(
+     *   isNonEmpty,
+     *   Refinement.compose(isTrimmed)
+     * );
+     * ```
+     */
+    const compose: <A, B extends A, C extends B>(bc: Refinement<B, C>) => (ab: Refinement<A, B>) => Refinement<A, C>;
+    /**
+     * Intersects two refinements: the result narrows `A` to `B & C`, passing only
+     * when both refinements hold simultaneously.
+     *
+     * Data-last — the first refinement is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const isString: Refinement<unknown, string> = Refinement.make(x => typeof x === "string");
+     * const isNonEmpty: Refinement<unknown, { length: number }> =
+     *   Refinement.make(x => (x as any).length > 0);
+     *
+     * const isNonEmptyString = pipe(isString, Refinement.and(isNonEmpty));
+     * isNonEmptyString("hi");  // true
+     * isNonEmptyString("");    // false
+     * ```
+     */
+    const and: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B & C>;
+    /**
+     * Unions two refinements: the result narrows `A` to `B | C`, passing when either
+     * refinement holds.
+     *
+     * Data-last — the first refinement is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const isString:  Refinement<unknown, string>  = Refinement.make(x => typeof x === "string");
+     * const isNumber:  Refinement<unknown, number>  = Refinement.make(x => typeof x === "number");
+     *
+     * const isStringOrNumber = pipe(isString, Refinement.or(isNumber));
+     * isStringOrNumber("hi"); // true
+     * isStringOrNumber(42);   // true
+     * isStringOrNumber(true); // false
+     * ```
+     */
+    const or: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B | C>;
+    /**
+     * Converts a `Refinement<A, B>` into a function `(a: A) => Option<B>`.
+     *
+     * Returns `Some(a)` when the refinement holds, `None` otherwise. Useful for
+     * integrating runtime validation into an `Option`-based pipeline.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = number & { readonly _tag: "Positive" };
+     * const isPositive: Refinement<number, PositiveNumber> =
+     *   Refinement.make(n => n > 0);
+     *
+     * pipe(-1, Refinement.toFilter(isPositive)); // None
+     * pipe(42, Refinement.toFilter(isPositive)); // Some(42)
+     * ```
+     */
+    const toFilter: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Option<B>;
+    /**
+     * Converts a `Refinement<A, B>` into a function `(a: A) => Result<E, B>`.
+     *
+     * Returns `Ok(a)` when the refinement holds, `Err(onFail(a))` otherwise. Use
+     * this to surface validation failures as typed errors inside a `Result` pipeline.
+     *
+     * @example
+     * ```ts
+     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
+     * const isNonEmpty: Refinement<string, NonEmptyString> =
+     *   Refinement.make(s => s.length > 0);
+     *
+     * pipe("", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Err(...)
+     * pipe("hi", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Ok("hi")
+     * ```
+     */
+    const toResult: <A, B extends A, E>(r: Refinement<A, B>, onFail: (a: A) => E) => (a: A) => Result<E, B>;
+}
+
+/**
+ * A boolean-valued function over a type `A`.
+ *
+ * A `Predicate<A>` is the simpler sibling of `Refinement<A, B>`: it tests whether a
+ * value satisfies a condition at runtime but carries no compile-time narrowing guarantee.
+ * Use it when you need to combine, negate, or adapt boolean checks as first-class values
+ * and do not require the extra type information that a `Refinement` provides.
+ *
+ * Every `Refinement<A, B>` is a `Predicate<A>` — convert with `Predicate.fromRefinement`
+ * when you want to compose a narrowing check alongside plain predicates.
+ *
+ * @example
+ * ```ts
+ * const isAdult: Predicate<number> = n => n >= 18;
+ * const isRetired: Predicate<number> = n => n >= 65;
+ *
+ * const isWorkingAge: Predicate<number> = pipe(
+ *   isAdult,
+ *   Predicate.and(Predicate.not(isRetired))
+ * );
+ *
+ * isWorkingAge(30);  // true
+ * isWorkingAge(15);  // false
+ * isWorkingAge(70);  // false
+ * ```
+ */
+type Predicate<A> = (a: A) => boolean;
+declare namespace Predicate {
+    /**
+     * Negates a predicate: the result passes exactly when the original fails.
+     *
+     * @example
+     * ```ts
+     * const isBlank: Predicate<string> = s => s.trim().length === 0;
+     * const isNotBlank = Predicate.not(isBlank);
+     *
+     * isNotBlank("hello");  // true
+     * isNotBlank("   ");    // false
+     * ```
+     */
+    const not: <A>(p: Predicate<A>) => Predicate<A>;
+    /**
+     * Combines two predicates with logical AND: passes only when both hold.
+     *
+     * Data-last — the first predicate is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const isPositive: Predicate<number> = n => n > 0;
+     * const isEven: Predicate<number> = n => n % 2 === 0;
+     *
+     * const isPositiveEven: Predicate<number> = pipe(isPositive, Predicate.and(isEven));
+     *
+     * isPositiveEven(4);   // true
+     * isPositiveEven(3);   // false — positive but odd
+     * isPositiveEven(-2);  // false — even but not positive
+     * ```
+     */
+    const and: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<A>;
+    /**
+     * Combines two predicates with logical OR: passes when either holds.
+     *
+     * Data-last — the first predicate is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const isChild: Predicate<number> = n => n < 13;
+     * const isSenior: Predicate<number> = n => n >= 65;
+     *
+     * const getsDiscount: Predicate<number> = pipe(isChild, Predicate.or(isSenior));
+     *
+     * getsDiscount(8);   // true
+     * getsDiscount(70);  // true
+     * getsDiscount(30);  // false
+     * ```
+     */
+    const or: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<A>;
+    /**
+     * Adapts a `Predicate<A>` to work on a different input type `B` by applying `f`
+     * to extract the relevant `A` from a `B` before running the check.
+     *
+     * Data-last — the predicate is the data being piped; `f` is the extractor.
+     *
+     * @example
+     * ```ts
+     * type User = { name: string; age: number };
+     *
+     * const isAdult: Predicate<number> = n => n >= 18;
+     *
+     * // Lift isAdult to work on Users by extracting the age field
+     * const isAdultUser: Predicate<User> = pipe(
+     *   isAdult,
+     *   Predicate.using((u: User) => u.age)
+     * );
+     *
+     * isAdultUser({ name: "Alice", age: 30 });  // true
+     * isAdultUser({ name: "Bob",   age: 15 });  // false
+     * ```
+     */
+    const using: <A, B>(f: (b: B) => A) => (p: Predicate<A>) => Predicate<B>;
+    /**
+     * Combines an array of predicates with AND: passes only when every predicate holds.
+     * Returns `true` for an empty array (vacuous truth).
+     *
+     * @example
+     * ```ts
+     * const checks: Predicate<string>[] = [
+     *   s => s.length > 0,
+     *   s => s.length <= 100,
+     *   s => !s.includes("<"),
+     * ];
+     *
+     * Predicate.all(checks)("hello");  // true
+     * Predicate.all(checks)("");       // false — too short
+     * Predicate.all(checks)("<b>");    // false — contains "<"
+     * Predicate.all([])("anything");   // true
+     * ```
+     */
+    const all: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<A>;
+    /**
+     * Combines an array of predicates with OR: passes when at least one holds.
+     * Returns `false` for an empty array.
+     *
+     * @example
+     * ```ts
+     * const acceptedFormats: Predicate<string>[] = [
+     *   s => s.endsWith(".jpg"),
+     *   s => s.endsWith(".png"),
+     *   s => s.endsWith(".webp"),
+     * ];
+     *
+     * Predicate.any(acceptedFormats)("photo.jpg");   // true
+     * Predicate.any(acceptedFormats)("photo.gif");   // false
+     * Predicate.any([])("anything");                 // false
+     * ```
+     */
+    const any: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<A>;
+    /**
+     * Converts a `Refinement<A, B>` into a `Predicate<A>`, discarding the compile-time
+     * narrowing. Use this when you want to combine a type guard with plain predicates
+     * using `and`, `or`, or `all`.
+     *
+     * @example
+     * ```ts
+     * const isString: Refinement<unknown, string> =
+     *   Refinement.make(x => typeof x === "string");
+     *
+     * const isShortString: Predicate<unknown> = pipe(
+     *   Predicate.fromRefinement(isString),
+     *   Predicate.and(x => (x as string).length < 10)
+     * );
+     *
+     * isShortString("hi");            // true
+     * isShortString("a very long string that exceeds ten characters");  // false
+     * isShortString(42);              // false
+     * ```
+     */
+    const fromRefinement: <A, B extends A>(r: Refinement<A, B>) => Predicate<A>;
+}
+
+/**
+ * A computation that reads from a shared environment `R` and produces a value `A`.
+ * Use Reader to thread a dependency (config, logger, DB pool) through a pipeline
+ * without passing it explicitly to every function.
+ *
+ * @example
+ * ```ts
+ * type Config = { baseUrl: string; apiKey: string };
+ *
+ * const buildUrl = (path: string): Reader<Config, string> =>
+ *   (config) => `${config.baseUrl}${path}`;
+ *
+ * const withAuth = (url: string): Reader<Config, string> =>
+ *   (config) => `${url}?key=${config.apiKey}`;
+ *
+ * const fetchEndpoint = (path: string): Reader<Config, string> =>
+ *   pipe(
+ *     buildUrl(path),
+ *     Reader.chain(withAuth)
+ *   );
+ *
+ * // Inject the config once at the edge
+ * fetchEndpoint("/users")(appConfig); // "https://api.example.com/users?key=secret"
+ * ```
+ */
+type Reader<R, A> = (env: R) => A;
+declare namespace Reader {
+    /**
+     * Lifts a pure value into a Reader. The environment is ignored.
+     *
+     * @example
+     * ```ts
+     * const always42: Reader<Config, number> = Reader.resolve(42);
+     * always42(anyConfig); // 42
+     * ```
+     */
+    const resolve: <R, A>(value: A) => Reader<R, A>;
+    /**
+     * Returns the full environment as the result.
+     * The fundamental way to access the environment in a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Reader.ask<Config>(),
+     *   Reader.map(config => config.baseUrl)
+     * )(appConfig); // "https://api.example.com"
+     * ```
+     */
+    const ask: <R>() => Reader<R, R>;
+    /**
+     * Projects a value from the environment using a selector function.
+     * Equivalent to `pipe(Reader.ask(), Reader.map(f))` but more direct.
+     *
+     * @example
+     * ```ts
+     * const getBaseUrl: Reader<Config, string> = Reader.asks(c => c.baseUrl);
+     * getBaseUrl(appConfig); // "https://api.example.com"
+     * ```
+     */
+    const asks: <R, A>(f: (env: R) => A) => Reader<R, A>;
+    /**
+     * Transforms the value produced by a Reader.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Reader.asks((c: Config) => c.baseUrl),
+     *   Reader.map(url => url.toUpperCase())
+     * )(appConfig); // "HTTPS://API.EXAMPLE.COM"
+     * ```
+     */
+    const map: <R, A, B>(f: (a: A) => B) => (data: Reader<R, A>) => Reader<R, B>;
+    /**
+     * Sequences two Readers. Both see the same environment.
+     * The output of the first is passed to `f`, which returns the next Reader.
+     *
+     * @example
+     * ```ts
+     * const buildUrl = (path: string): Reader<Config, string> =>
+     *   Reader.asks(c => `${c.baseUrl}${path}`);
+     *
+     * const addAuth = (url: string): Reader<Config, string> =>
+     *   Reader.asks(c => `${url}?key=${c.apiKey}`);
+     *
+     * pipe(
+     *   buildUrl("/items"),
+     *   Reader.chain(addAuth)
+     * )(appConfig); // "https://api.example.com/items?key=secret"
+     * ```
+     */
+    const chain: <R, A, B>(f: (a: A) => Reader<R, B>) => (data: Reader<R, A>) => Reader<R, B>;
+    /**
+     * Applies a function wrapped in a Reader to a value wrapped in a Reader.
+     * Both Readers see the same environment.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   Reader.resolve<Config, typeof add>(add),
+     *   Reader.ap(Reader.asks(c => c.timeout)),
+     *   Reader.ap(Reader.resolve(5))
+     * )(appConfig);
+     * ```
+     */
+    const ap: <R, A>(arg: Reader<R, A>) => <B>(data: Reader<R, (a: A) => B>) => Reader<R, B>;
+    /**
+     * Executes a side effect on the produced value without changing the Reader.
+     * Useful for logging or debugging inside a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   buildUrl("/users"),
+     *   Reader.tap(url => console.log("Requesting:", url)),
+     *   Reader.chain(addAuth)
+     * )(appConfig);
+     * ```
+     */
+    const tap: <R, A>(f: (a: A) => void) => (data: Reader<R, A>) => Reader<R, A>;
+    /**
+     * Adapts a Reader to work with a different (typically wider) environment
+     * by transforming the environment before passing it to the Reader.
+     * This lets you compose Readers that expect different environments.
+     *
+     * @example
+     * ```ts
+     * type AppEnv = { db: DbPool; config: Config; logger: Logger };
+     *
+     * // buildUrl only needs Config
+     * const buildUrl: Reader<Config, string> = Reader.asks(c => c.baseUrl);
+     *
+     * // Zoom in from AppEnv to Config
+     * const buildUrlFromApp: Reader<AppEnv, string> =
+     *   pipe(buildUrl, Reader.local((env: AppEnv) => env.config));
+     *
+     * buildUrlFromApp(appEnv); // works with the full AppEnv
+     * ```
+     */
+    const local: <R2, R>(f: (env: R2) => R) => <A>(data: Reader<R, A>) => Reader<R2, A>;
+    /**
+     * Runs a Reader by supplying the environment. Use this at the edge of your
+     * program where the environment is available.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   buildEndpoint("/users"),
+     *   Reader.run(appConfig)
+     * ); // "https://api.example.com/users?key=secret"
+     * ```
+     */
+    const run: <R>(env: R) => <A>(data: Reader<R, A>) => A;
+}
+
+type NotAsked = WithKind<"NotAsked">;
+type Loading = WithKind<"Loading">;
+type Failure<E> = WithKind<"Failure"> & WithError<E>;
+type Success<A> = WithKind<"Success"> & WithValue<A>;
+/**
+ * RemoteData represents the state of an async data fetch.
+ * It has four states: NotAsked, Loading, Failure, and Success.
+ *
+ * Use RemoteData to model data fetching states explicitly,
+ * replacing the common `{ data: T | null; loading: boolean; error: Error | null }` pattern.
+ *
+ * @example
+ * ```ts
+ * const renderUser = pipe(
+ *   userData,
+ *   RemoteData.match({
+ *     notAsked: () => "Click to load",
+ *     loading: () => "Loading...",
+ *     failure: e => `Error: ${e.message}`,
+ *     success: user => `Hello, ${user.name}!`
+ *   })
+ * );
+ * ```
+ */
+type RemoteData<E, A> = NotAsked | Loading | Failure<E> | Success<A>;
+declare namespace RemoteData {
+    /**
+     * Creates a NotAsked RemoteData.
+     */
+    const notAsked: <E, A>() => RemoteData<E, A>;
+    /**
+     * Creates a Loading RemoteData.
+     */
+    const loading: <E, A>() => RemoteData<E, A>;
+    /**
+     * Creates a Failure RemoteData with the given error.
+     */
+    const failure: <E, A>(error: E) => RemoteData<E, A>;
+    /**
+     * Creates a Success RemoteData with the given value.
+     */
+    const success: <E, A>(value: A) => RemoteData<E, A>;
+    /**
+     * Type guard that checks if a RemoteData is NotAsked.
+     */
+    const isNotAsked: <E, A>(data: RemoteData<E, A>) => data is NotAsked;
+    /**
+     * Type guard that checks if a RemoteData is Loading.
+     */
+    const isLoading: <E, A>(data: RemoteData<E, A>) => data is Loading;
+    /**
+     * Type guard that checks if a RemoteData is Failure.
+     */
+    const isFailure: <E, A>(data: RemoteData<E, A>) => data is Failure<E>;
+    /**
+     * Type guard that checks if a RemoteData is Success.
+     */
+    const isSuccess: <E, A>(data: RemoteData<E, A>) => data is Success<A>;
+    /**
+     * Transforms the success value inside a RemoteData.
+     *
+     * @example
+     * ```ts
+     * pipe(RemoteData.success(5), RemoteData.map(n => n * 2)); // Success(10)
+     * pipe(RemoteData.loading(), RemoteData.map(n => n * 2)); // Loading
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => <E>(data: RemoteData<E, A>) => RemoteData<E, B>;
+    /**
+     * Transforms the error value inside a RemoteData.
+     *
+     * @example
+     * ```ts
+     * pipe(RemoteData.failure("oops"), RemoteData.mapError(e => e.toUpperCase())); // Failure("OOPS")
+     * ```
+     */
+    const mapError: <E, F>(f: (e: E) => F) => <A>(data: RemoteData<E, A>) => RemoteData<F, A>;
+    /**
+     * Chains RemoteData computations. If the input is Success, passes the value to f.
+     * Otherwise, propagates the current state.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   RemoteData.success(5),
+     *   RemoteData.chain(n => n > 0 ? RemoteData.success(n) : RemoteData.failure("negative"))
+     * );
+     * ```
+     */
+    const chain: <E, A, B>(f: (a: A) => RemoteData<E, B>) => (data: RemoteData<E, A>) => RemoteData<E, B>;
+    /**
+     * Applies a function wrapped in a RemoteData to a value wrapped in a RemoteData.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   RemoteData.success(add),
+     *   RemoteData.ap(RemoteData.success(5)),
+     *   RemoteData.ap(RemoteData.success(3))
+     * ); // Success(8)
+     * ```
+     */
+    const ap: <E, A>(arg: RemoteData<E, A>) => <B>(data: RemoteData<E, (a: A) => B>) => RemoteData<E, B>;
+    /**
+     * Extracts the value from a RemoteData by providing handlers for all four cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   userData,
+     *   RemoteData.fold(
+     *     () => "Not asked",
+     *     () => "Loading...",
+     *     e => `Error: ${e}`,
+     *     value => `Got: ${value}`
+     *   )
+     * );
+     * ```
+     */
+    const fold: <E, A, B>(onNotAsked: () => B, onLoading: () => B, onFailure: (e: E) => B, onSuccess: (a: A) => B) => (data: RemoteData<E, A>) => B;
+    /**
+     * Pattern matches on a RemoteData, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   userData,
+     *   RemoteData.match({
+     *     notAsked: () => "Click to load",
+     *     loading: () => "Loading...",
+     *     failure: e => `Error: ${e}`,
+     *     success: user => `Hello, ${user.name}!`
+     *   })
+     * );
+     * ```
+     */
+    const match: <E, A, B>(cases: {
+        notAsked: () => B;
+        loading: () => B;
+        failure: (e: E) => B;
+        success: (a: A) => B;
+    }) => (data: RemoteData<E, A>) => B;
+    /**
+     * Returns the success value or a default value if the RemoteData is not Success.
+     * The default can be a different type, widening the result to `A | B`.
+     *
+     * @example
+     * ```ts
+     * pipe(RemoteData.success(5), RemoteData.getOrElse(() => 0)); // 5
+     * pipe(RemoteData.loading(), RemoteData.getOrElse(() => 0)); // 0
+     * pipe(RemoteData.loading<string, number>(), RemoteData.getOrElse(() => null)); // null — typed as number | null
+     * ```
+     */
+    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: RemoteData<E, A>) => A | B;
+    /**
+     * Executes a side effect on the success value without changing the RemoteData.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   RemoteData.success(5),
+     *   RemoteData.tap(n => console.log("Value:", n)),
+     *   RemoteData.map(n => n * 2)
+     * );
+     * ```
+     */
+    const tap: <E, A>(f: (a: A) => void) => (data: RemoteData<E, A>) => RemoteData<E, A>;
+    /**
+     * Recovers from a Failure state by providing a fallback RemoteData.
+     * The fallback can produce a different success type, widening the result to `RemoteData<E, A | B>`.
+     */
+    const recover: <E, A, B>(fallback: (e: E) => RemoteData<E, B>) => (data: RemoteData<E, A>) => RemoteData<E, A | B>;
+    /**
+     * Converts a RemoteData to an Option.
+     * Success becomes Some, all other states become None.
+     */
+    const toOption: <E, A>(data: RemoteData<E, A>) => Option<A>;
+    /**
+     * Converts a RemoteData to a Result.
+     * Success becomes Ok, Failure becomes Err.
+     * NotAsked and Loading become Err with the provided fallback error.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   RemoteData.success(42),
+     *   RemoteData.toResult(() => "not loaded")
+     * ); // Ok(42)
+     * ```
+     */
+    const toResult: <E>(onNotReady: () => E) => <A>(data: RemoteData<E, A>) => Result<E, A>;
+}
+
+/**
+ * A synchronous computation that threads a piece of mutable state `S` through
+ * a pipeline without exposing mutation at call sites.
+ *
+ * At runtime a `State<S, A>` is just a function from an initial state to a pair
+ * `[value, nextState]`. Nothing runs until you supply the initial state with
+ * `State.run`, `State.evaluate`, or `State.execute`.
+ *
+ * @example
+ * ```ts
+ * type Counter = number;
+ *
+ * const increment: State<Counter, undefined> = State.modify(n => n + 1);
+ * const getCount:  State<Counter, Counter>   = State.get();
+ *
+ * const program = pipe(
+ *   increment,
+ *   State.chain(() => increment),
+ *   State.chain(() => getCount),
+ * );
+ *
+ * State.run(0)(program); // [2, 2]  — value is 2, final state is 2
+ * ```
+ */
+type State<S, A> = (s: S) => readonly [A, S];
+declare namespace State {
+    /**
+     * Lifts a pure value into a State computation. The state passes through unchanged.
+     *
+     * @example
+     * ```ts
+     * State.run(10)(State.resolve(42)); // [42, 10] — value 42, state unchanged
+     * ```
+     */
+    const resolve: <S, A>(value: A) => State<S, A>;
+    /**
+     * Produces the current state as the value, without modifying it.
+     *
+     * @example
+     * ```ts
+     * const readStack: State<string[], string[]> = State.get();
+     * State.run(["a", "b"])(readStack); // [["a", "b"], ["a", "b"]]
+     * ```
+     */
+    const get: <S>() => State<S, S>;
+    /**
+     * Reads a projection of the state without modifying it.
+     * Equivalent to `pipe(State.get(), State.map(f))` but more direct.
+     *
+     * @example
+     * ```ts
+     * type AppState = { count: number; label: string };
+     * const readCount: State<AppState, number> = State.gets(s => s.count);
+     * State.run({ count: 5, label: "x" })(readCount); // [5, { count: 5, label: "x" }]
+     * ```
+     */
+    const gets: <S, A>(f: (s: S) => A) => State<S, A>;
+    /**
+     * Replaces the current state with a new value. Produces no meaningful value.
+     *
+     * @example
+     * ```ts
+     * const reset: State<number, undefined> = State.put(0);
+     * State.run(99)(reset); // [undefined, 0]
+     * ```
+     */
+    const put: <S>(newState: S) => State<S, undefined>;
+    /**
+     * Applies a function to the current state to produce the next state.
+     * Produces no meaningful value.
+     *
+     * @example
+     * ```ts
+     * const push = (item: string): State<string[], undefined> =>
+     *   State.modify(stack => [...stack, item]);
+     *
+     * State.run(["a"])(push("b")); // [undefined, ["a", "b"]]
+     * ```
+     */
+    const modify: <S>(f: (s: S) => S) => State<S, undefined>;
+    /**
+     * Transforms the value produced by a State computation.
+     * The state transformation is unchanged.
+     *
+     * @example
+     * ```ts
+     * const readLength: State<string[], number> = pipe(
+     *   State.get<string[]>(),
+     *   State.map(stack => stack.length),
+     * );
+     *
+     * State.run(["a", "b", "c"])(readLength); // [3, ["a", "b", "c"]]
+     * ```
+     */
+    const map: <S, A, B>(f: (a: A) => B) => (st: State<S, A>) => State<S, B>;
+    /**
+     * Sequences two State computations. The state output of the first is passed
+     * as the state input to the second.
+     *
+     * Data-last — the first computation is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const push = (item: string): State<string[], undefined> =>
+     *   State.modify(stack => [...stack, item]);
+     *
+     * const program = pipe(
+     *   push("a"),
+     *   State.chain(() => push("b")),
+     *   State.chain(() => State.get<string[]>()),
+     * );
+     *
+     * State.evaluate([])(program); // ["a", "b"]
+     * ```
+     */
+    const chain: <S, A, B>(f: (a: A) => State<S, B>) => (st: State<S, A>) => State<S, B>;
+    /**
+     * Applies a function wrapped in a State to a value wrapped in a State.
+     * The function computation runs first; its output state is the input to the
+     * argument computation.
+     *
+     * @example
+     * ```ts
+     * const addCounted = (n: number) => (m: number) => n + m;
+     * const program = pipe(
+     *   State.resolve<number, typeof addCounted>(addCounted),
+     *   State.ap(State.gets((s: number) => s * 2)),
+     *   State.ap(State.gets((s: number) => s)),
+     * );
+     *
+     * State.evaluate(3)(program); // 6 + 3 = 9
+     * ```
+     */
+    const ap: <S, A>(arg: State<S, A>) => <B>(fn: State<S, (a: A) => B>) => State<S, B>;
+    /**
+     * Runs a side effect on the produced value without changing the State computation.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   State.get<number>(),
+     *   State.tap(n => console.log("current:", n)),
+     *   State.chain(() => State.modify(n => n + 1)),
+     * );
+     * ```
+     */
+    const tap: <S, A>(f: (a: A) => void) => (st: State<S, A>) => State<S, A>;
+    /**
+     * Runs a State computation with an initial state, returning both the
+     * produced value and the final state as a pair.
+     *
+     * Data-last — the computation is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const program = pipe(
+     *   State.modify<number>(n => n + 1),
+     *   State.chain(() => State.get<number>()),
+     * );
+     *
+     * State.run(0)(program); // [1, 1]
+     * ```
+     */
+    const run: <S>(initialState: S) => <A>(st: State<S, A>) => readonly [A, S];
+    /**
+     * Runs a State computation with an initial state, returning only the
+     * produced value (discarding the final state).
+     *
+     * @example
+     * ```ts
+     * State.evaluate([])(pipe(
+     *   State.modify<string[]>(s => [...s, "x"]),
+     *   State.chain(() => State.get<string[]>()),
+     * )); // ["x"]
+     * ```
+     */
+    const evaluate: <S>(initialState: S) => <A>(st: State<S, A>) => A;
+    /**
+     * Runs a State computation with an initial state, returning only the
+     * final state (discarding the produced value).
+     *
+     * @example
+     * ```ts
+     * State.execute(0)(pipe(
+     *   State.modify<number>(n => n + 10),
+     *   State.chain(() => State.modify<number>(n => n * 2)),
+     * )); // 20
+     * ```
+     */
+    const execute: <S>(initialState: S) => <A>(st: State<S, A>) => S;
+}
+
+/**
+ * A Task that can fail with an error of type E or succeed with a value of type A.
+ * Combines async operations with typed error handling.
+ *
+ * @example
+ * ```ts
+ * const fetchUser = (id: string): TaskResult<Error, User> =>
+ *   TaskResult.tryCatch(
+ *     () => fetch(`/users/${id}`).then(r => r.json()),
+ *     (e) => new Error(`Failed to fetch user: ${e}`)
+ *   );
+ * ```
+ */
+type TaskResult<E, A> = Task<Result<E, A>>;
+declare namespace TaskResult {
+    /**
+     * Wraps a value in a successful TaskResult.
+     */
+    const ok: <E, A>(value: A) => TaskResult<E, A>;
+    /**
+     * Creates a failed TaskResult with the given error.
+     */
+    const err: <E, A>(error: E) => TaskResult<E, A>;
+    /**
+     * Creates a TaskResult from a function that may throw.
+     * Catches any errors and transforms them using the onError function.
+     *
+     * @example
+     * ```ts
+     * const parseJson = (s: string): TaskResult<string, unknown> =>
+     *   TaskResult.tryCatch(
+     *     async () => JSON.parse(s),
+     *     (e) => `Parse error: ${e}`
+     *   );
+     * ```
+     */
+    const tryCatch: <E, A>(f: () => Promise<A>, onError: (e: unknown) => E) => TaskResult<E, A>;
+    /**
+     * Transforms the success value inside a TaskResult.
+     */
+    const map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
+    /**
+     * Transforms the error value inside a TaskResult.
+     */
+    const mapError: <E, F, A>(f: (e: E) => F) => (data: TaskResult<E, A>) => TaskResult<F, A>;
+    /**
+     * Chains TaskResult computations. If the first succeeds, passes the value to f.
+     * If the first fails, propagates the error.
+     */
+    const chain: <E, A, B>(f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, B>;
+    /**
+     * Extracts the value from a TaskResult by providing handlers for both cases.
+     */
+    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: TaskResult<E, A>) => Task<B>;
+    /**
+     * Pattern matches on a TaskResult, returning a Task of the result.
+     */
+    const match: <E, A, B>(cases: {
+        err: (e: E) => B;
+        ok: (a: A) => B;
+    }) => (data: TaskResult<E, A>) => Task<B>;
+    /**
+     * Recovers from an error by providing a fallback TaskResult.
+     * The fallback can produce a different success type, widening the result to `TaskResult<E, A | B>`.
+     */
+    const recover: <E, A, B>(fallback: (e: E) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A | B>;
+    /**
+     * Returns the success value or a default value if the TaskResult is an error.
+     * The default can be a different type, widening the result to `Task<A | B>`.
+     */
+    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskResult<E, A>) => Task<A | B>;
+    /**
+     * Executes a side effect on the success value without changing the TaskResult.
+     * Useful for logging or debugging.
+     */
+    const tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+    /**
+     * Re-runs a TaskResult on `Err` with configurable attempts, backoff, and retry condition.
+     *
+     * @param options.attempts - Total number of attempts (1 = no retry, 3 = up to 3 tries)
+     * @param options.backoff - Fixed delay in ms, or a function `(attempt) => ms` for computed delay
+     * @param options.when - Only retry when this returns true; defaults to always retry on Err
+     *
+     * @example
+     * ```ts
+     * // Retry up to 3 times with exponential backoff
+     * pipe(
+     *   fetchUser,
+     *   TaskResult.retry({ attempts: 3, backoff: n => n * 1000 })
+     * );
+     *
+     * // Only retry on network errors, not auth errors
+     * pipe(
+     *   fetchUser,
+     *   TaskResult.retry({ attempts: 3, when: e => e instanceof NetworkError })
+     * );
+     * ```
+     */
+    const retry: <E>(options: {
+        attempts: number;
+        backoff?: number | ((attempt: number) => number);
+        when?: (error: E) => boolean;
+    }) => <A>(data: TaskResult<E, A>) => TaskResult<E, A>;
+    /**
+     * Fails a TaskResult with a typed error if it does not resolve within the given time.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   fetchUser,
+     *   TaskResult.timeout(5000, () => new TimeoutError("fetch user timed out"))
+     * );
+     * ```
+     */
+    const timeout: <E>(ms: number, onTimeout: () => E) => <A>(data: TaskResult<E, A>) => TaskResult<E, A>;
+}
+
+/**
+ * A Task that resolves to an optional value.
+ * Combines async operations with the Option type for values that may not exist.
+ *
+ * @example
+ * ```ts
+ * const findUser = (id: string): TaskOption<User> =>
+ *   TaskOption.tryCatch(() => db.users.findById(id));
+ *
+ * pipe(
+ *   findUser("123"),
+ *   TaskOption.map(user => user.name),
+ *   TaskOption.getOrElse(() => "Unknown")
+ * )();
+ * ```
+ */
+type TaskOption<A> = Task<Option<A>>;
+declare namespace TaskOption {
+    /**
+     * Wraps a value in a Some inside a Task.
+     */
+    const some: <A>(value: A) => TaskOption<A>;
+    /**
+     * Creates a TaskOption that resolves to None.
+     */
+    const none: <A = never>() => TaskOption<A>;
+    /**
+     * Lifts an Option into a TaskOption.
+     */
+    const fromOption: <A>(option: Option<A>) => TaskOption<A>;
+    /**
+     * Lifts a Task into a TaskOption by wrapping its result in Some.
+     */
+    const fromTask: <A>(task: Task<A>) => TaskOption<A>;
+    /**
+     * Creates a TaskOption from a Promise-returning function.
+     * Returns Some if the promise resolves, None if it rejects.
+     *
+     * @example
+     * ```ts
+     * const fetchUser = TaskOption.tryCatch(() =>
+     *   fetch("/user/1").then(r => r.json())
+     * );
+     * ```
+     */
+    const tryCatch: <A>(f: () => Promise<A>) => TaskOption<A>;
+    /**
+     * Transforms the value inside a TaskOption.
+     */
+    const map: <A, B>(f: (a: A) => B) => (data: TaskOption<A>) => TaskOption<B>;
+    /**
+     * Chains TaskOption computations. If the first resolves to Some, passes the
+     * value to f. If the first resolves to None, propagates None.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   TaskOption.chain(user => findOrg(user.orgId))
+     * )();
+     * ```
+     */
+    const chain: <A, B>(f: (a: A) => TaskOption<B>) => (data: TaskOption<A>) => TaskOption<B>;
+    /**
+     * Applies a function wrapped in a TaskOption to a value wrapped in a TaskOption.
+     * Both Tasks run in parallel.
+     */
+    const ap: <A>(arg: TaskOption<A>) => <B>(data: TaskOption<(a: A) => B>) => TaskOption<B>;
+    /**
+     * Extracts a value from a TaskOption by providing handlers for both cases.
+     */
+    const fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskOption<A>) => Task<B>;
+    /**
+     * Pattern matches on a TaskOption, returning a Task of the result.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   TaskOption.match({
+     *     some: user => `Hello, ${user.name}`,
+     *     none: () => "User not found"
+     *   })
+     * )();
+     * ```
+     */
+    const match: <A, B>(cases: {
+        none: () => B;
+        some: (a: A) => B;
+    }) => (data: TaskOption<A>) => Task<B>;
+    /**
+     * Returns the value or a default if the TaskOption resolves to None.
+     * The default can be a different type, widening the result to `Task<A | B>`.
+     */
+    const getOrElse: <A, B>(defaultValue: () => B) => (data: TaskOption<A>) => Task<A | B>;
+    /**
+     * Executes a side effect on the value without changing the TaskOption.
+     * Useful for logging or debugging.
+     */
+    const tap: <A>(f: (a: A) => void) => (data: TaskOption<A>) => TaskOption<A>;
+    /**
+     * Filters the value inside a TaskOption. Returns None if the predicate fails.
+     */
+    const filter: <A>(predicate: (a: A) => boolean) => (data: TaskOption<A>) => TaskOption<A>;
+    /**
+     * Converts a TaskOption to a TaskResult, using onNone to produce the error value.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   TaskOption.toTaskResult(() => "User not found")
+     * );
+     * ```
+     */
+    const toTaskResult: <E>(onNone: () => E) => <A>(data: TaskOption<A>) => TaskResult<E, A>;
+}
+
+type Valid<A> = WithKind<"Valid"> & WithValue<A>;
+type Invalid<E> = WithKind<"Invalid"> & WithErrors<E>;
+/**
+ * Validation represents a value that is either valid with a success value,
+ * or invalid with accumulated errors.
+ * Unlike Result, Validation can accumulate multiple errors instead of short-circuiting.
+ *
+ * Use Validation when you need to collect all errors (e.g., form validation).
+ * Use Result when you want to fail fast on the first error.
+ *
+ * @example
+ * ```ts
+ * const validateName = (name: string): Validation<string, string> =>
+ *   name.length > 0 ? Validation.valid(name) : Validation.invalid("Name is required");
+ *
+ * const validateAge = (age: number): Validation<string, number> =>
+ *   age >= 0 ? Validation.valid(age) : Validation.invalid("Age must be positive");
+ *
+ * // Accumulates all errors using ap
+ * pipe(
+ *   Validation.valid((name: string) => (age: number) => ({ name, age })),
+ *   Validation.ap(validateName("")),
+ *   Validation.ap(validateAge(-1))
+ * );
+ * // Invalid(["Name is required", "Age must be positive"])
+ * ```
+ */
+type Validation<E, A> = Valid<A> | Invalid<E>;
+declare namespace Validation {
+    /**
+     * Wraps a value in a valid Validation.
+     *
+     * @example
+     * ```ts
+     * Validation.valid(42); // Valid(42)
+     * ```
+     */
+    const valid: <E, A>(value: A) => Validation<E, A>;
+    /**
+     * Creates an invalid Validation from a single error.
+     *
+     * @example
+     * ```ts
+     * Validation.invalid("Invalid input");
+     * ```
+     */
+    const invalid: <E>(error: E) => Invalid<E>;
+    /**
+     * Creates an invalid Validation from multiple errors.
+     *
+     * @example
+     * ```ts
+     * Validation.invalidAll(["Invalid input"]);
+     * ```
+     */
+    const invalidAll: <E>(errors: NonEmptyList<E>) => Invalid<E>;
+    /**
+     * Type guard that checks if a Validation is valid.
+     */
+    const isValid: <E, A>(data: Validation<E, A>) => data is Valid<A>;
+    /**
+     * Type guard that checks if a Validation is invalid.
+     */
+    const isInvalid: <E, A>(data: Validation<E, A>) => data is Invalid<E>;
+    /**
+     * Transforms the success value inside a Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.valid(5), Validation.map(n => n * 2)); // Valid(10)
+     * pipe(Validation.invalid("oops"), Validation.map(n => n * 2)); // Invalid(["oops"])
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => <E>(data: Validation<E, A>) => Validation<E, B>;
+    /**
+     * Applies a function wrapped in a Validation to a value wrapped in a Validation.
+     * Accumulates errors from both sides.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   Validation.valid(add),
+     *   Validation.ap(Validation.valid(5)),
+     *   Validation.ap(Validation.valid(3))
+     * ); // Valid(8)
+     *
+     * pipe(
+     *   Validation.valid(add),
+     *   Validation.ap(Validation.invalid<string, number>("bad a")),
+     *   Validation.ap(Validation.invalid<string, number>("bad b"))
+     * ); // Invalid(["bad a", "bad b"])
+     * ```
+     */
+    const ap: <E, A>(arg: Validation<E, A>) => <B>(data: Validation<E, (a: A) => B>) => Validation<E, B>;
+    /**
+     * Extracts the value from a Validation by providing handlers for both cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Validation.valid(42),
+     *   Validation.fold(
+     *     errors => `Errors: ${errors.join(", ")}`,
+     *     value => `Value: ${value}`
+     *   )
+     * );
+     * ```
+     */
+    const fold: <E, A, B>(onInvalid: (errors: NonEmptyList<E>) => B, onValid: (a: A) => B) => (data: Validation<E, A>) => B;
+    /**
+     * Pattern matches on a Validation, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   validation,
+     *   Validation.match({
+     *     valid: value => `Got ${value}`,
+     *     invalid: errors => `Failed: ${errors.join(", ")}`
+     *   })
+     * );
+     * ```
+     */
+    const match: <E, A, B>(cases: {
+        valid: (a: A) => B;
+        invalid: (errors: NonEmptyList<E>) => B;
+    }) => (data: Validation<E, A>) => B;
+    /**
+     * Returns the success value or a default value if the Validation is invalid.
+     * The default can be a different type, widening the result to `A | B`.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.valid(5), Validation.getOrElse(() => 0)); // 5
+     * pipe(Validation.invalid("oops"), Validation.getOrElse(() => 0)); // 0
+     * pipe(Validation.invalid("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
+     * ```
+     */
+    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Validation<E, A>) => A | B;
+    /**
+     * Executes a side effect on the success value without changing the Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Validation.valid(5),
+     *   Validation.tap(n => console.log("Value:", n)),
+     *   Validation.map(n => n * 2)
+     * );
+     * ```
+     */
+    const tap: <E, A>(f: (a: A) => void) => (data: Validation<E, A>) => Validation<E, A>;
+    /**
+     * Recovers from an Invalid state by providing a fallback Validation.
+     * The fallback receives the accumulated error list so callers can inspect which errors occurred.
+     * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
+     */
+    const recover: <E, A, B>(fallback: (errors: NonEmptyList<E>) => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
+    /**
+     * Recovers from an Invalid state unless the errors contain any of the blocked errors.
+     * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
+     */
+    const recoverUnless: <E, A, B>(blockedErrors: readonly E[], fallback: () => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
+    /**
+     * Combines two independent Validation instances into a tuple.
+     * If both are Valid, returns Valid with both values as a tuple.
+     * If either is Invalid, accumulates errors from both sides.
+     *
+     * @example
+     * ```ts
+     * Validation.product(
+     *   Validation.valid("alice"),
+     *   Validation.valid(30)
+     * ); // Valid(["alice", 30])
+     *
+     * Validation.product(
+     *   Validation.invalid("Name required"),
+     *   Validation.invalid("Age must be >= 0")
+     * ); // Invalid(["Name required", "Age must be >= 0"])
+     * ```
+     */
+    const product: <E, A, B>(first: Validation<E, A>, second: Validation<E, B>) => Validation<E, readonly [A, B]>;
+    /**
+     * Combines a non-empty list of Validation instances, accumulating all errors.
+     * If all are Valid, returns Valid with all values collected into an array.
+     * If any are Invalid, returns Invalid with all accumulated errors.
+     *
+     * @example
+     * ```ts
+     * Validation.productAll([
+     *   validateName(name),
+     *   validateEmail(email),
+     *   validateAge(age)
+     * ]);
+     * // Valid([name, email, age]) or Invalid([...all errors])
+     * ```
+     */
+    const productAll: <E, A>(data: NonEmptyList<Validation<E, A>>) => Validation<E, readonly A[]>;
+}
+
+/**
+ * A Task that resolves to a Validation — combining async operations with
+ * error accumulation. Unlike TaskResult, multiple failures are collected
+ * rather than short-circuiting on the first error.
+ *
+ * @example
+ * ```ts
+ * const validateName = (name: string): TaskValidation<string, string> =>
+ *   name.length > 0
+ *     ? TaskValidation.valid(name)
+ *     : TaskValidation.invalid("Name is required");
+ *
+ * // Accumulate errors from multiple async validations using ap
+ * pipe(
+ *   TaskValidation.valid((name: string) => (age: number) => ({ name, age })),
+ *   TaskValidation.ap(validateName("")),
+ *   TaskValidation.ap(validateAge(-1))
+ * )();
+ * // Invalid(["Name is required", "Age must be positive"])
+ * ```
+ */
+type TaskValidation<E, A> = Task<Validation<E, A>>;
+declare namespace TaskValidation {
+    /**
+     * Wraps a value in a valid TaskValidation.
+     */
+    const valid: <E, A>(value: A) => TaskValidation<E, A>;
+    /**
+     * Creates a failed TaskValidation with a single error.
+     */
+    const invalid: <E, A>(error: E) => TaskValidation<E, A>;
+    /**
+     * Creates an invalid TaskValidation from multiple errors.
+     */
+    const invalidAll: <E, A>(errors: NonEmptyList<E>) => TaskValidation<E, A>;
+    /**
+     * Lifts a Validation into a TaskValidation.
+     */
+    const fromValidation: <E, A>(validation: Validation<E, A>) => TaskValidation<E, A>;
+    /**
+     * Creates a TaskValidation from a Promise-returning function.
+     * Catches any errors and transforms them using the onError function.
+     *
+     * @example
+     * ```ts
+     * const fetchUser = (id: string): TaskValidation<string, User> =>
+     *   TaskValidation.tryCatch(
+     *     () => fetch(`/users/${id}`).then(r => r.json()),
+     *     e => `Failed to fetch user: ${e}`
+     *   );
+     * ```
+     */
+    const tryCatch: <E, A>(f: () => Promise<A>, onError: (e: unknown) => E) => TaskValidation<E, A>;
+    /**
+     * Transforms the success value inside a TaskValidation.
+     */
+    const map: <E, A, B>(f: (a: A) => B) => (data: TaskValidation<E, A>) => TaskValidation<E, B>;
+    /**
+     * Applies a function wrapped in a TaskValidation to a value wrapped in a
+     * TaskValidation. Both Tasks run in parallel and errors from both sides
+     * are accumulated.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskValidation.valid((name: string) => (age: number) => ({ name, age })),
+     *   TaskValidation.ap(validateName(name)),
+     *   TaskValidation.ap(validateAge(age))
+     * )();
+     * ```
+     */
+    const ap: <E, A>(arg: TaskValidation<E, A>) => <B>(data: TaskValidation<E, (a: A) => B>) => TaskValidation<E, B>;
+    /**
+     * Extracts a value from a TaskValidation by providing handlers for both cases.
+     */
+    const fold: <E, A, B>(onInvalid: (errors: NonEmptyList<E>) => B, onValid: (a: A) => B) => (data: TaskValidation<E, A>) => Task<B>;
+    /**
+     * Pattern matches on a TaskValidation, returning a Task of the result.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   validateForm(input),
+     *   TaskValidation.match({
+     *     valid: data => save(data),
+     *     invalid: errors => showErrors(errors)
+     *   })
+     * )();
+     * ```
+     */
+    const match: <E, A, B>(cases: {
+        valid: (a: A) => B;
+        invalid: (errors: NonEmptyList<E>) => B;
+    }) => (data: TaskValidation<E, A>) => Task<B>;
+    /**
+     * Returns the success value or a default value if the TaskValidation is invalid.
+     * The default can be a different type, widening the result to `Task<A | B>`.
+     */
+    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskValidation<E, A>) => Task<A | B>;
+    /**
+     * Executes a side effect on the success value without changing the TaskValidation.
+     * Useful for logging or debugging.
+     */
+    const tap: <E, A>(f: (a: A) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
+    /**
+     * Recovers from an Invalid state by providing a fallback TaskValidation.
+     * The fallback receives the accumulated error list so callers can inspect which errors occurred.
+     * The fallback can produce a different success type, widening the result to `TaskValidation<E, A | B>`.
+     */
+    const recover: <E, A, B>(fallback: (errors: NonEmptyList<E>) => TaskValidation<E, B>) => (data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
+    /**
+     * Runs two TaskValidations concurrently and combines their results into a tuple.
+     * If both are Valid, returns Valid with both values. If either fails, accumulates
+     * errors from both sides.
+     *
+     * @example
+     * ```ts
+     * await TaskValidation.product(
+     *   validateName(form.name),
+     *   validateAge(form.age),
+     * )(); // Valid(["Alice", 30]) or Invalid([...errors])
+     * ```
+     */
+    const product: <E, A, B>(first: TaskValidation<E, A>, second: TaskValidation<E, B>) => TaskValidation<E, readonly [A, B]>;
+    /**
+     * Runs all TaskValidations concurrently and collects results.
+     * If all are Valid, returns Valid with all values as an array.
+     * If any fail, returns Invalid with all accumulated errors.
+     *
+     * @example
+     * ```ts
+     * await TaskValidation.productAll([
+     *   validateName(form.name),
+     *   validateEmail(form.email),
+     *   validateAge(form.age),
+     * ])(); // Valid([name, email, age]) or Invalid([...all errors])
+     * ```
+     */
+    const productAll: <E, A>(data: NonEmptyList<TaskValidation<E, A>>) => TaskValidation<E, readonly A[]>;
+}
+
+type TheseFirst<T> = WithKind<"First"> & WithFirst<T>;
+type TheseSecond<T> = WithKind<"Second"> & WithSecond<T>;
+type TheseBoth<First, Second> = WithKind<"Both"> & WithFirst<First> & WithSecond<Second>;
+/**
+ * These<A, B> is an inclusive-OR type: it holds a first value (A), a second
+ * value (B), or both simultaneously. Neither side carries a success/failure
+ * connotation — it is a neutral pair where any combination is valid.
+ *
+ * - First(a)     — only a first value
+ * - Second(b)    — only a second value
+ * - Both(a, b)   — first and second values simultaneously
+ *
+ * A common use: lenient parsers or processors that carry a diagnostic note
+ * alongside a result, without losing either piece of information.
+ *
+ * @example
+ * ```ts
+ * const parse = (s: string): These<number, string> => {
+ *   const trimmed = s.trim();
+ *   const n = parseFloat(trimmed);
+ *   if (isNaN(n)) return These.second("Not a number");
+ *   if (s !== trimmed) return These.both(n, "Leading/trailing whitespace trimmed");
+ *   return These.first(n);
+ * };
+ * ```
+ */
+type These<A, B> = TheseFirst<A> | TheseSecond<B> | TheseBoth<A, B>;
+declare namespace These {
+    /**
+     * Creates a These holding only a first value.
+     *
+     * @example
+     * ```ts
+     * These.first(42); // { kind: "First", first: 42 }
+     * ```
+     */
+    const first: <A>(value: A) => TheseFirst<A>;
+    /**
+     * Creates a These holding only a second value.
+     *
+     * @example
+     * ```ts
+     * These.second("warning"); // { kind: "Second", second: "warning" }
+     * ```
+     */
+    const second: <B>(value: B) => TheseSecond<B>;
+    /**
+     * Creates a These holding both a first and a second value simultaneously.
+     *
+     * @example
+     * ```ts
+     * These.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
+     * ```
+     */
+    const both: <A, B>(first: A, second: B) => TheseBoth<A, B>;
+    /**
+     * Type guard — checks if a These holds only a first value.
+     */
+    const isFirst: <A, B>(data: These<A, B>) => data is TheseFirst<A>;
+    /**
+     * Type guard — checks if a These holds only a second value.
+     */
+    const isSecond: <A, B>(data: These<A, B>) => data is TheseSecond<B>;
+    /**
+     * Type guard — checks if a These holds both values simultaneously.
+     */
+    const isBoth: <A, B>(data: These<A, B>) => data is TheseBoth<A, B>;
+    /**
+     * Returns true if the These contains a first value (First or Both).
+     */
+    const hasFirst: <A, B>(data: These<A, B>) => data is TheseFirst<A> | TheseBoth<A, B>;
+    /**
+     * Returns true if the These contains a second value (Second or Both).
+     */
+    const hasSecond: <A, B>(data: These<A, B>) => data is TheseSecond<B> | TheseBoth<A, B>;
+    /**
+     * Transforms the first value, leaving the second unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(These.first(5), These.mapFirst(n => n * 2));           // First(10)
+     * pipe(These.both(5, "warn"), These.mapFirst(n => n * 2));    // Both(10, "warn")
+     * pipe(These.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
+     * ```
+     */
+    const mapFirst: <A, C>(f: (a: A) => C) => <B>(data: These<A, B>) => These<C, B>;
+    /**
+     * Transforms the second value, leaving the first unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(These.second("warn"), These.mapSecond(e => e.toUpperCase()));     // Second("WARN")
+     * pipe(These.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")
+     * ```
+     */
+    const mapSecond: <B, D>(f: (b: B) => D) => <A>(data: These<A, B>) => These<A, D>;
+    /**
+     * Transforms both the first and second values independently.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   These.both(5, "warn"),
+     *   These.mapBoth(n => n * 2, e => e.toUpperCase())
+     * ); // Both(10, "WARN")
+     * ```
+     */
+    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (data: These<A, B>) => These<C, D>;
+    /**
+     * Chains These computations by passing the first value to f.
+     * Second propagates unchanged; First and Both apply f to the first value.
+     *
+     * @example
+     * ```ts
+     * const double = (n: number): These<number, string> => These.first(n * 2);
+     *
+     * pipe(These.first(5), These.chainFirst(double));            // First(10)
+     * pipe(These.both(5, "warn"), These.chainFirst(double));     // First(10)
+     * pipe(These.second("warn"), These.chainFirst(double));      // Second("warn")
+     * ```
+     */
+    const chainFirst: <A, B, C>(f: (a: A) => These<C, B>) => (data: These<A, B>) => These<C, B>;
+    /**
+     * Chains These computations by passing the second value to f.
+     * First propagates unchanged; Second and Both apply f to the second value.
+     *
+     * @example
+     * ```ts
+     * const shout = (s: string): These<number, string> => These.second(s.toUpperCase());
+     *
+     * pipe(These.second("warn"), These.chainSecond(shout));      // Second("WARN")
+     * pipe(These.both(5, "warn"), These.chainSecond(shout));     // Second("WARN")
+     * pipe(These.first(5), These.chainSecond(shout));            // First(5)
+     * ```
+     */
+    const chainSecond: <A, B, D>(f: (b: B) => These<A, D>) => (data: These<A, B>) => These<A, D>;
+    /**
+     * Extracts a value from a These by providing handlers for all three cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   these,
+     *   These.fold(
+     *     a => `First: ${a}`,
+     *     b => `Second: ${b}`,
+     *     (a, b) => `Both: ${a} / ${b}`
+     *   )
+     * );
+     * ```
+     */
+    const fold: <A, B, C>(onFirst: (a: A) => C, onSecond: (b: B) => C, onBoth: (a: A, b: B) => C) => (data: These<A, B>) => C;
+    /**
+     * Pattern matches on a These, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   these,
+     *   These.match({
+     *     first: a => `First: ${a}`,
+     *     second: b => `Second: ${b}`,
+     *     both: (a, b) => `Both: ${a} / ${b}`
+     *   })
+     * );
+     * ```
+     */
+    const match: <A, B, C>(cases: {
+        first: (a: A) => C;
+        second: (b: B) => C;
+        both: (a: A, b: B) => C;
+    }) => (data: These<A, B>) => C;
+    /**
+     * Returns the first value, or a default if the These has no first value.
+     * The default can be a different type, widening the result to `A | C`.
+     *
+     * @example
+     * ```ts
+     * pipe(These.first(5), These.getFirstOrElse(() => 0));            // 5
+     * pipe(These.both(5, "warn"), These.getFirstOrElse(() => 0));     // 5
+     * pipe(These.second("warn"), These.getFirstOrElse(() => 0));      // 0
+     * pipe(These.second("warn"), These.getFirstOrElse(() => null));   // null — typed as number | null
+     * ```
+     */
+    const getFirstOrElse: <A, C>(defaultValue: () => C) => <B>(data: These<A, B>) => A | C;
+    /**
+     * Returns the second value, or a default if the These has no second value.
+     * The default can be a different type, widening the result to `B | D`.
+     *
+     * @example
+     * ```ts
+     * pipe(These.second("warn"), These.getSecondOrElse(() => "none")); // "warn"
+     * pipe(These.both(5, "warn"), These.getSecondOrElse(() => "none")); // "warn"
+     * pipe(These.first(5), These.getSecondOrElse(() => "none"));       // "none"
+     * pipe(These.first(5), These.getSecondOrElse(() => null));         // null — typed as string | null
+     * ```
+     */
+    const getSecondOrElse: <B, D>(defaultValue: () => D) => <A>(data: These<A, B>) => B | D;
+    /**
+     * Executes a side effect on the first value without changing the These.
+     * Useful for logging or debugging.
+     *
+     * @example
+     * ```ts
+     * pipe(These.first(5), These.tap(console.log)); // logs 5, returns First(5)
+     * ```
+     */
+    const tap: <A>(f: (a: A) => void) => <B>(data: These<A, B>) => These<A, B>;
+    /**
+     * Swaps the roles of first and second values.
+     * - First(a)    → Second(a)
+     * - Second(b)   → First(b)
+     * - Both(a, b)  → Both(b, a)
+     *
+     * @example
+     * ```ts
+     * These.swap(These.first(5));            // Second(5)
+     * These.swap(These.second("warn"));      // First("warn")
+     * These.swap(These.both(5, "warn"));     // Both("warn", 5)
+     * ```
+     */
+    const swap: <A, B>(data: These<A, B>) => These<B, A>;
+}
+
+/**
+ * Tuple<A, B> represents a pair of two values that are always both present.
+ * It is a typed alias for `readonly [A, B]`.
+ *
+ * Use Tuple when two values always travel together through a pipeline and you
+ * want to transform either or both sides without destructuring.
+ *
+ * @example
+ * ```ts
+ * import { Tuple } from "@nlozgachev/pipelined/core";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * const entry = Tuple.make("alice", 42);
+ *
+ * pipe(
+ *   entry,
+ *   Tuple.mapFirst((name) => name.toUpperCase()),
+ *   Tuple.mapSecond((score) => score * 2),
+ *   Tuple.fold((name, score) => `${name}: ${score}`),
+ * ); // "ALICE: 84"
+ * ```
+ */
+type Tuple<A, B> = readonly [A, B];
+declare namespace Tuple {
+    /**
+     * Creates a pair from two values.
+     *
+     * @example
+     * ```ts
+     * Tuple.make("Paris", 2_161_000); // ["Paris", 2161000]
+     * ```
+     */
+    const make: <A, B>(first: A, second: B) => Tuple<A, B>;
+    /**
+     * Returns the first value from the pair.
+     *
+     * @example
+     * ```ts
+     * Tuple.first(Tuple.make("Paris", 2_161_000)); // "Paris"
+     * ```
+     */
+    const first: <A, B>(tuple: Tuple<A, B>) => A;
+    /**
+     * Returns the second value from the pair.
+     *
+     * @example
+     * ```ts
+     * Tuple.second(Tuple.make("Paris", 2_161_000)); // 2161000
+     * ```
+     */
+    const second: <A, B>(tuple: Tuple<A, B>) => B;
+    /**
+     * Transforms the first value, leaving the second unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Tuple.make("alice", 42), Tuple.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
+     * ```
+     */
+    const mapFirst: <A, C>(f: (a: A) => C) => <B>(tuple: Tuple<A, B>) => Tuple<C, B>;
+    /**
+     * Transforms the second value, leaving the first unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Tuple.make("alice", 42), Tuple.mapSecond((n) => n * 2)); // ["alice", 84]
+     * ```
+     */
+    const mapSecond: <B, D>(f: (b: B) => D) => <A>(tuple: Tuple<A, B>) => Tuple<A, D>;
+    /**
+     * Transforms both values independently in a single step.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Tuple.make("alice", 42),
+     *   Tuple.mapBoth(
+     *     (name) => name.toUpperCase(),
+     *     (score) => score * 2,
+     *   ),
+     * ); // ["ALICE", 84]
+     * ```
+     */
+    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (tuple: Tuple<A, B>) => Tuple<C, D>;
+    /**
+     * Applies a binary function to both values, collapsing the pair into a single value.
+     * Useful as the final step when consuming a pair in a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(Tuple.make("Alice", 100), Tuple.fold((name, score) => `${name}: ${score}`));
+     * // "Alice: 100"
+     * ```
+     */
+    const fold: <A, B, C>(f: (a: A, b: B) => C) => (tuple: Tuple<A, B>) => C;
+    /**
+     * Swaps the two values: `[A, B]` becomes `[B, A]`.
+     *
+     * @example
+     * ```ts
+     * Tuple.swap(Tuple.make("key", 1)); // [1, "key"]
+     * ```
+     */
+    const swap: <A, B>(tuple: Tuple<A, B>) => Tuple<B, A>;
+    /**
+     * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
+     *
+     * @example
+     * ```ts
+     * Tuple.toArray(Tuple.make("hello", 42)); // ["hello", 42]
+     * ```
+     */
+    const toArray: <A, B>(tuple: Tuple<A, B>) => readonly (A | B)[];
+    /**
+     * Runs a side effect with both values without changing the pair.
+     * Useful for logging or debugging in the middle of a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Tuple.make("Paris", 2_161_000),
+     *   Tuple.tap((city, pop) => console.log(`${city}: ${pop}`)),
+     *   Tuple.mapSecond((n) => n / 1_000_000),
+     * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
+     * ```
+     */
+    const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
+}
+
+export { type Failure, type Invalid, Lens, type Loading, Logged, type NotAsked, Option, Optional, Predicate, Reader, Refinement, RemoteData, Result, State, type Success, Task, TaskOption, TaskResult, TaskValidation, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple, type Valid, Validation };