@shirudo/result 0.0.6 → 1.0.0

package/dist/index.d.mts

@@ -1,361 +1,15 @@
-//#region src/core/pipeable.d.ts
-type UnaryFunction<Input, Output> = (input: Input) => Output;
-type Awaitable<T> = T | Promise<T>;
-declare abstract class Pipeable {
-  pipe<A>(this: A): A;
-  pipe<A, B>(this: A, ab: UnaryFunction<A, B>): B;
-  pipe<A, B, C>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>): C;
-  pipe<A, B, C, D>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>): D;
-  pipe<A, B, C, D, E>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>): E;
-  pipe<A, B, C, D, E, F>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>): F;
-  pipe<A, B, C, D, E, F, G>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>): G;
-  pipe<A, B, C, D, E, F, G, H>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>): H;
-  pipe<A, B, C, D, E, F, G, H, I>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>): I;
-  pipe<A, B, C, D, E, F, G, H, I, J>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>): J;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>): K$1;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1, L>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>, kl: UnaryFunction<K$1, L>): L;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>, kl: UnaryFunction<K$1, L>, lm: UnaryFunction<L, M>): M;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>, kl: UnaryFunction<K$1, L>, lm: UnaryFunction<L, M>, mn: UnaryFunction<M, N>): N;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>, kl: UnaryFunction<K$1, L>, lm: UnaryFunction<L, M>, mn: UnaryFunction<M, N>, no: UnaryFunction<N, O>): O;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>, kl: UnaryFunction<K$1, L>, lm: UnaryFunction<L, M>, mn: UnaryFunction<M, N>, no: UnaryFunction<N, O>, op: UnaryFunction<O, P>): P;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>, kl: UnaryFunction<K$1, L>, lm: UnaryFunction<L, M>, mn: UnaryFunction<M, N>, no: UnaryFunction<N, O>, op: UnaryFunction<O, P>, pq: UnaryFunction<P, Q>): Q;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R$1>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>, kl: UnaryFunction<K$1, L>, lm: UnaryFunction<L, M>, mn: UnaryFunction<M, N>, no: UnaryFunction<N, O>, op: UnaryFunction<O, P>, pq: UnaryFunction<P, Q>, qr: UnaryFunction<Q, R$1>): R$1;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R$1, S>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>, kl: UnaryFunction<K$1, L>, lm: UnaryFunction<L, M>, mn: UnaryFunction<M, N>, no: UnaryFunction<N, O>, op: UnaryFunction<O, P>, pq: UnaryFunction<P, Q>, qr: UnaryFunction<Q, R$1>, rs: UnaryFunction<R$1, S>): S;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R$1, S, T>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>, kl: UnaryFunction<K$1, L>, lm: UnaryFunction<L, M>, mn: UnaryFunction<M, N>, no: UnaryFunction<N, O>, op: UnaryFunction<O, P>, pq: UnaryFunction<P, Q>, qr: UnaryFunction<Q, R$1>, rs: UnaryFunction<R$1, S>, st: UnaryFunction<S, T>): T;
-  pipe<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R$1, S, T, U>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>, de: UnaryFunction<D, E>, ef: UnaryFunction<E, F>, fg: UnaryFunction<F, G>, gh: UnaryFunction<G, H>, hi: UnaryFunction<H, I>, ij: UnaryFunction<I, J>, jk: UnaryFunction<J, K$1>, kl: UnaryFunction<K$1, L>, lm: UnaryFunction<L, M>, mn: UnaryFunction<M, N>, no: UnaryFunction<N, O>, op: UnaryFunction<O, P>, pq: UnaryFunction<P, Q>, qr: UnaryFunction<Q, R$1>, rs: UnaryFunction<R$1, S>, st: UnaryFunction<S, T>, tu: UnaryFunction<T, U>): U;
-  pipeAsync<A>(this: A): Promise<A>;
-  pipeAsync<A, B>(this: A, ab: UnaryFunction<A, B>): Promise<Awaited<B>>;
-  pipeAsync<A, B, C>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>): Promise<Awaited<C>>;
-  pipeAsync<A, B, C, D>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>): Promise<Awaited<D>>;
-  pipeAsync<A, B, C, D, E>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>): Promise<Awaited<E>>;
-  pipeAsync<A, B, C, D, E, F>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>): Promise<Awaited<F>>;
-  pipeAsync<A, B, C, D, E, F, G>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>): Promise<Awaited<G>>;
-  pipeAsync<A, B, C, D, E, F, G, H>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>): Promise<Awaited<H>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>): Promise<Awaited<I>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>): Promise<Awaited<J>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>): Promise<Awaited<K$1>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1, L>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>, kl: UnaryFunction<Awaited<K$1>, L>): Promise<Awaited<L>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1, L, M>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>, kl: UnaryFunction<Awaited<K$1>, L>, lm: UnaryFunction<Awaited<L>, M>): Promise<Awaited<M>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>, kl: UnaryFunction<Awaited<K$1>, L>, lm: UnaryFunction<Awaited<L>, M>, mn: UnaryFunction<Awaited<M>, N>): Promise<Awaited<N>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>, kl: UnaryFunction<Awaited<K$1>, L>, lm: UnaryFunction<Awaited<L>, M>, mn: UnaryFunction<Awaited<M>, N>, no: UnaryFunction<Awaited<N>, O>): Promise<Awaited<O>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>, kl: UnaryFunction<Awaited<K$1>, L>, lm: UnaryFunction<Awaited<L>, M>, mn: UnaryFunction<Awaited<M>, N>, no: UnaryFunction<Awaited<N>, O>, op: UnaryFunction<Awaited<O>, P>): Promise<Awaited<P>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>, kl: UnaryFunction<Awaited<K$1>, L>, lm: UnaryFunction<Awaited<L>, M>, mn: UnaryFunction<Awaited<M>, N>, no: UnaryFunction<Awaited<N>, O>, op: UnaryFunction<Awaited<O>, P>, pq: UnaryFunction<Awaited<P>, Q>): Promise<Awaited<Q>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R$1>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>, kl: UnaryFunction<Awaited<K$1>, L>, lm: UnaryFunction<Awaited<L>, M>, mn: UnaryFunction<Awaited<M>, N>, no: UnaryFunction<Awaited<N>, O>, op: UnaryFunction<Awaited<O>, P>, pq: UnaryFunction<Awaited<P>, Q>, qr: UnaryFunction<Awaited<Q>, R$1>): Promise<Awaited<R$1>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R$1, S>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>, kl: UnaryFunction<Awaited<K$1>, L>, lm: UnaryFunction<Awaited<L>, M>, mn: UnaryFunction<Awaited<M>, N>, no: UnaryFunction<Awaited<N>, O>, op: UnaryFunction<Awaited<O>, P>, pq: UnaryFunction<Awaited<P>, Q>, qr: UnaryFunction<Awaited<Q>, R$1>, rs: UnaryFunction<Awaited<R$1>, S>): Promise<Awaited<S>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R$1, S, T>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>, kl: UnaryFunction<Awaited<K$1>, L>, lm: UnaryFunction<Awaited<L>, M>, mn: UnaryFunction<Awaited<M>, N>, no: UnaryFunction<Awaited<N>, O>, op: UnaryFunction<Awaited<O>, P>, pq: UnaryFunction<Awaited<P>, Q>, qr: UnaryFunction<Awaited<Q>, R$1>, rs: UnaryFunction<Awaited<R$1>, S>, st: UnaryFunction<Awaited<S>, T>): Promise<Awaited<T>>;
-  pipeAsync<A, B, C, D, E, F, G, H, I, J, K$1, L, M, N, O, P, Q, R$1, S, T, U>(this: A, ab: UnaryFunction<A, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>, de: UnaryFunction<Awaited<D>, E>, ef: UnaryFunction<Awaited<E>, F>, fg: UnaryFunction<Awaited<F>, G>, gh: UnaryFunction<Awaited<G>, H>, hi: UnaryFunction<Awaited<H>, I>, ij: UnaryFunction<Awaited<I>, J>, jk: UnaryFunction<Awaited<J>, K$1>, kl: UnaryFunction<Awaited<K$1>, L>, lm: UnaryFunction<Awaited<L>, M>, mn: UnaryFunction<Awaited<M>, N>, no: UnaryFunction<Awaited<N>, O>, op: UnaryFunction<Awaited<O>, P>, pq: UnaryFunction<Awaited<P>, Q>, qr: UnaryFunction<Awaited<Q>, R$1>, rs: UnaryFunction<Awaited<R$1>, S>, st: UnaryFunction<Awaited<S>, T>, tu: UnaryFunction<Awaited<T>, U>): Promise<Awaited<U>>;
-}
-//#endregion
-//#region src/core/matcher.d.ts
-type Ctor<T> = abstract new (...args: any[]) => T;
-type TypeGuard<E, A extends E> = (error: E) => error is A;
-/**
- * Matcher for Err values (returns an arbitrary return type, e.g. string messages).
- *
- * - `.when(Ctor, handler)` matches via `instanceof`
- * - `.whenGuard(guard, handler)` matches via Type-Guard
- * - `.run()` is only allowed if all error cases have been handled (`E` has been reduced to `never`)
- */
-declare class ErrorMatchBuilder<E, R$1> {
-  #private;
-  constructor(error: unknown, matched?: boolean, value?: unknown);
-  when<C extends Ctor<E>, R1>(ctor: C, handler: (error: InstanceType<C>) => R1): ErrorMatchBuilder<Exclude<E, InstanceType<C>>, R$1 | R1>;
-  whenGuard<A extends E, R1>(guard: TypeGuard<E, A>, handler: (error: A) => R1): ErrorMatchBuilder<Exclude<E, A>, R$1 | R1>;
-  otherwise<R2>(handler: (error: E) => R2): R$1 | R2;
-  run(this: ErrorMatchBuilder<never, R$1>): R$1;
-}
-type OkOfReturn$1<R$1> = R$1 extends Result<infer T, any> ? T : never;
-type ErrOfReturn$1<R$1> = R$1 extends Result<any, infer E> ? E : R$1;
-type ErrFactory = <E>(error: E) => Result<never, E>;
-/**
- * Matcher for `Result` Errors, which returns a `Result` again.
- *
- * Handlers may:
- * - return a `Result` (is returned directly)
- * - return an Error value (is automatically wrapped into `Err(error)`)
- */
-declare class ErrMatchBuilder<T, E, OutT, OutE> {
-  #private;
-  private constructor();
-  static fromResult<T, E>(result: Result<T, E>, makeErr: ErrFactory): ErrMatchBuilder<T, E, never, never>;
-  when<C extends Ctor<E>, R1>(ctor: C, handler: (error: InstanceType<C>) => R1): ErrMatchBuilder<T, Exclude<E, InstanceType<C>>, OutT | OkOfReturn$1<R1>, OutE | ErrOfReturn$1<R1>>;
-  whenGuard<A extends E, R1>(guard: TypeGuard<E, A>, handler: (error: A) => R1): ErrMatchBuilder<T, Exclude<E, A>, OutT | OkOfReturn$1<R1>, OutE | ErrOfReturn$1<R1>>;
-  otherwise<R2>(handler: (error: E) => R2): Result<T | OutT | OkOfReturn$1<R2>, OutE | ErrOfReturn$1<R2>>;
-  run(this: ErrMatchBuilder<T, never, OutT, OutE>): Result<T | OutT, OutE>;
-}
-//#endregion
-//#region src/core/map.d.ts
-/**
- * Transforms the value (Ok case).
- * Corresponds to Rust `map`.
- */
-declare function map<T, E, U>(project: (value: T) => U): (source: Result<T, E>) => Result<U, E>;
-//#endregion
-//#region src/core/mapErr.d.ts
-/**
- * Transforms the error (Err case).
- * Corresponds to Rust `map_err`.
- */
-declare function mapErr<T, E, F>(project: (error: E) => F): (source: Result<T, E>) => Result<T, F>;
-//#endregion
-//#region src/core/mapBoth.d.ts
-/**
- * Transforms both the Ok value and the Err error.
- * Corresponds to FP `bimap` / `mapBoth`.
- */
-declare function mapBoth<T, E, U, F>(mapOk: (value: T) => U, mapErr: (error: E) => F): (source: Result<T, E>) => Result<U, F>;
-/**
- * Alias for `mapBoth`.
- */
-declare const bimap: typeof mapBoth;
-//#endregion
-//#region src/core/flatMap.d.ts
-/**
- * Chains another operation that returns a Result.
- * Corresponds to Rust `and_then` or JS `flatMap`.
- */
-declare function flatMap<T, E, U>(project: (value: T) => Result<U, E>): (source: Result<T, E>) => Result<U, E>;
-//#endregion
-//#region src/core/zip.d.ts
-/**
- * Combines two Results into a Result of a tuple.
- * Short-circuits on the first Err (left before right).
- */
-declare function zip<A, AE, B, BE>(left: Result<A, AE>, right: Result<B, BE>): Result<[A, B], AE | BE>;
-declare function zip<A, AE, B, BE>(right: Result<B, BE>): (left: Result<A, AE>) => Result<[A, B], AE | BE>;
-/**
- * Combines two Results and collects errors.
- * - Ok only if both are Ok
- * - Err([errors]) if at least one is Err (left before right)
- */
-declare function combine<A, AE, B, BE>(left: Result<A, AE>, right: Result<B, BE>): Result<[A, B], Array<AE | BE>>;
-declare function combine<A, AE, B, BE>(right: Result<B, BE>): (left: Result<A, AE>) => Result<[A, B], Array<AE | BE>>;
-//#endregion
-//#region src/core/tap.d.ts
-/**
- * Executes a side effect (logging, debugging) without changing the Result.
- * Corresponds to Rust `inspect` / `inspect_err`.
- */
-declare function tap<T, E>(observer: {
-  ok?: (val: T) => void;
-  err?: (e: E) => void;
-}): (source: Result<T, E>) => Result<T, E>;
-//#endregion
-//#region src/core/filter.d.ts
-/**
- * Checks a condition. If false, the Result becomes Err.
- * Corresponds to Rust `filter` (partially).
- */
-declare function filter<T, E>(predicate: (val: T) => boolean, errorFn: () => E): (source: Result<T, E>) => Result<T, E>;
-//#endregion
-//#region src/core/match.d.ts
-/**
- * Resolves the Result. The end of the pipe.
- * Corresponds to Rust `match`.
- */
-declare function match<T, E, R$1>(handlers: {
-  ok: (val: T) => R$1;
-  err: (e: E) => R$1;
-}): (source: Result<T, E>) => R$1;
-//#endregion
-//#region src/core/recover.d.ts
-/**
- * Recover: converts Err to Ok(defaultValue).
- * Result is guaranteed to be Ok → Error type becomes `never`.
- */
-declare function recover<T, E, F>(defaultValue: F): (source: Result<T, E>) => Result<T | F, never>;
-/**
- * Like `recover`, but calculates the default value based on the error.
- */
-declare function recoverWith<T, E, F>(fn: (error: E) => F): (source: Result<T, E>) => Result<T | F, never>;
-//#endregion
-//#region src/core/swap.d.ts
-/**
- * Swaps Ok and Err.
- * Result<T, E> → Result<E, T>
- */
-declare function swap<T, E>(result: Result<T, E>): Result<E, T>;
-//#endregion
-//#region src/core/tryCatch.d.ts
-/**
- * Executes a function and catches exceptions.
- * Converts exceptions into Result<E>.
- * Corresponds to Rust `Result::from` for fallible operations.
- */
-declare function tryCatch<T, E = unknown>(fn: () => T, errorMapper?: (error: unknown) => E): (source: Result<any, any>) => Result<T, E>;
-//#endregion
-//#region src/core/tryMap.d.ts
-/**
- * Like `map`, but catches exceptions and converts them to Err.
- */
-declare function tryMap<T, E, U, F = unknown>(project: (value: T) => U, errorMapper?: (error: unknown) => F): (source: Result<T, E>) => Result<U, E | F>;
-//#endregion
-//#region src/core/collectFirstOk.d.ts
-type OkValueOf$2<R$1> = R$1 extends Result<infer T, any> ? T : never;
-type ErrValueOf$2<R$1> = R$1 extends Result<any, infer E> ? E : never;
-/**
- * Parse a set of `Result`s, short-circuits when an input value is `Ok`.
- * If no `Ok` is found, returns an `Err` containing the collected error values.
- * Useful for "try multiple approaches until one works" patterns.
- */
-declare function collectFirstOk<const Results extends readonly Result<any, any>[]>(results: Results): Result<OkValueOf$2<Results[number]>, ErrValueOf$2<Results[number]>[]>;
-//#endregion
-//#region src/core/mapAsync.d.ts
-/**
- * Async version of map.
- */
-declare function mapAsync<T, E, U>(project: (value: T) => Promise<U>): (source: Result<T, E>) => Promise<Result<U, E>>;
-//#endregion
-//#region src/core/mapErrAsync.d.ts
-/**
- * Async version of mapErr.
- */
-declare function mapErrAsync<T, E, F>(project: (error: E) => Promise<F>): (source: Result<T, E>) => Promise<Result<T, F>>;
-//#endregion
-//#region src/core/flatMapAsync.d.ts
-/**
- * Async version of flatMap.
- */
-declare function flatMapAsync<T, E, U>(project: (value: T) => Promise<Result<U, E>>): (source: Result<T, E>) => Promise<Result<U, E>>;
-//#endregion
-//#region src/core/tapAsync.d.ts
-/**
- * Async version of tap.
- */
-declare function tapAsync<T, E>(observer: {
-  ok?: (val: T) => Promise<void>;
-  err?: (e: E) => Promise<void>;
-}): (source: Result<T, E>) => Promise<Result<T, E>>;
-//#endregion
-//#region src/core/filterAsync.d.ts
-/**
- * Async version of filter.
- */
-declare function filterAsync<T, E>(predicate: (val: T) => Promise<boolean>, errorFn: () => Promise<E>): (source: Result<T, E>) => Promise<Result<T, E>>;
-//#endregion
-//#region src/core/matchAsync.d.ts
-/**
- * Async version of match.
- */
-declare function matchAsync<T, E, R$1>(handlers: {
-  ok: (val: T) => Promise<R$1>;
-  err: (e: E) => Promise<R$1>;
-}): (source: Result<T, E>) => Promise<R$1>;
-//#endregion
-//#region src/core/tryCatchAsync.d.ts
-/**
- * Async version of tryCatch.
- */
-declare function tryCatchAsync<T, E = unknown>(fn: () => Promise<T>, errorMapper?: (error: unknown) => E): (source: Result<any, any>) => Promise<Result<T, E>>;
-//#endregion
-//#region src/core/tryMapAsync.d.ts
-/**
- * Async version of tryMap.
- */
-declare function tryMapAsync<T, E, U, F = unknown>(project: (value: T) => Promise<U>, errorMapper?: (error: unknown) => F): (source: Result<T, E>) => Promise<Result<U, E | F>>;
-//#endregion
-//#region src/core/result.d.ts
-type OperatorFunction<T, E, R$1> = (input: Result<T, E>) => R$1;
-type AsyncOperatorFunction<T, E, R$1> = (input: Result<T, E>) => Promise<R$1>;
-type ResultType<T, E> = {
-  readonly _tag: 'Ok';
-  readonly value: T;
-} | {
-  readonly _tag: 'Err';
-  readonly error: E;
-};
-type Result<T, E> = Ok<T, E> | Err<T, E>;
-type OkValue<R$1> = R$1 extends {
-  readonly _tag: 'Ok';
-  readonly value: infer T;
-} ? T : never;
-declare abstract class ResultBase extends Pipeable {
-  abstract readonly _tag: 'Ok' | 'Err';
-  abstract readonly value: unknown;
-  abstract readonly error: unknown;
-  isOk<T, E>(this: Result<T, E>): this is Ok<T, E>;
-  isErr<T, E>(this: Result<T, E>): this is Err<T, E>;
-  unwrapOr<T, E>(this: Result<T, E>, defaultValue: T): T;
-  /**
-   * Folds the Result into a single value by applying one of two functions.
-   */
-  fold<T, E, R1, R2 = R1>(this: Result<T, E>, onOk: (value: T) => R1, onErr: (error: E) => R2): R1 | R2;
-  /**
-   * Enables `yield* result` in generators (Do-notation).
-   *
-   * The iterator yields the `Result` itself; the runner (see `task`) decides:
-   * - Ok  → sends back the Ok value (`next(value)`), `yield*` yields `T`
-   * - Err → aborts and returns the Err Result
-   */
-  [Symbol.iterator](): Generator<unknown, OkValue<this>, unknown>;
-  /**
-   * Matches on the Err value via `.when(...)` chain.
-   *
-   * Note: for type safety reasons, `.match()` can only be called on a Result already narrowed to `Err`,
-   * e.g. inside `if (result.isErr()) { ... }`.
-   */
-  match<T, E>(this: Result<T, E>): ErrorMatchBuilder<E, never>;
-  /**
-   * Matches on the Err value, but normalizes every branch to a `Result`:
-   * - Handlers may return a `Result` (is returned directly)
-   * - or an Error value (is wrapped into `Err(error)`)
-   */
-  matchErr<T, E>(this: Result<T, E>): ErrMatchBuilder<T, E, never, never>;
-  /**
-   * Serializes the Result into a simple object format.
-   * Preserves the original types.
-   */
-  serialize<T, E>(this: Result<T, E>): {
-    isSuccess: boolean;
-    data?: T;
-    error?: E;
-  };
-  /**
-   * Serializes the Result into a user-friendly format.
-   * Converts Errors to readable strings.
-   */
-  toUserFriendly<T, E>(this: Result<T, E>): {
-    isSuccess: boolean;
-    data?: T;
-    error?: string;
-  };
-}
-declare class Ok<T, E = never> extends ResultBase {
-  readonly _tag: "Ok";
-  readonly value: T;
-  readonly error: undefined;
-  constructor(value: T);
-}
-declare class Err<T = never, E = never> extends ResultBase {
-  readonly _tag: "Err";
-  readonly value: undefined;
-  readonly error: E;
-  constructor(error: E);
-}
-declare function ok(): Result<void, never>;
-declare function ok<T, E = never>(value: T): Result<T, E>;
-declare function err<E, T = never>(error: E): Result<T, E>;
-declare function okIf<T, E>(condition: boolean, okValue: T, errValue: E): Result<T, E>;
-declare function okIfLazy<T, E>(condition: boolean, okFn: () => T, errFn: () => E): Result<T, E>;
-declare function fromNullable<T, E>(value: T, error: E): Result<NonNullable<T>, E>;
-declare function fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;
-declare function fromPromise<T, E>(promise: Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>>;
-declare function tryFn<T>(fn: () => T): Result<T, unknown>;
-declare const Result: {
-  ok: typeof ok;
-  err: typeof err;
-  fromNullable: typeof fromNullable;
-  fromPromise: typeof fromPromise;
-  try: typeof tryFn;
-};
-//#endregion
+import { A as recover, B as combine, C as flatMapAsync, D as tryMap, E as collectFirstOk, F as flatMap, H as isResult, I as bimap, L as mapBoth, M as match, N as filter, O as tryCatch, P as tap, R as mapErr, S as tapAsync, T as mapAsync, U as matchTag, V as zip, W as Awaitable, _ as tryFn, a as Ok, b as matchAsync, c as ResultType, d as fromPromise, f as fromThrowable, g as tryAsync, h as okIfLazy, i as Err, j as recoverWith, k as swap, l as err, m as okIf, n as sequence, o as OperatorFunction, p as ok, r as AsyncOperatorFunction, s as Result, t as all, u as fromNullable, v as tryMapAsync, w as mapErrAsync, x as filterAsync, y as tryCatchAsync, z as map } from "./sequence-C0jlR3AY.mjs";
+import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as sequenceRecord, r as collectAllErrors, t as flatten } from "./flatten-B8bN6fiI.mjs";
+import { _ as ResultTypeError, a as ERR_MATCH_ERR_HANDLER_NOT_RESULT, b as UnwrapOnErrError, c as ERR_UNWRAP_ERR_ON_OK, d as ExpectOkError, f as InvalidResultStateError, g as ResultErrorCode, h as ResultError, i as ERR_INVALID_STATE, l as ERR_UNWRAP_ON_ERR, m as MatchOnOkError, n as ERR_EXPECT_OK, o as ERR_MATCH_ON_OK, p as MatchErrHandlerNotResultError, r as ERR_INVALID_RESULT_STATE, s as ERR_TASK_YIELD_NOT_RESULT, t as ERR_EXPECT_ERR, u as ExpectErrError, v as TaskYieldNotResultError, y as UnwrapErrOnOkError } from "./errors-C5qGMRiU.mjs";
+import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-B5gx9x2E.mjs";
+
 //#region src/gen.d.ts
-type AnyGenerator<Y = unknown, R$1 = unknown, N = unknown> = Generator<Y, R$1, N> | AsyncGenerator<Y, R$1, N>;
+type AnyGenerator<Y = unknown, R = unknown, N = unknown> = Generator<Y, R, N> | AsyncGenerator<Y, R, N>;
 type ErrorOfYield<Y> = Y extends Result<any, infer E> ? E : never;
 type OnThrow<E> = (error: unknown) => E;
-type AwaitedReturn<R$1> = Awaited<R$1>;
-type OkOfReturn<R$1> = AwaitedReturn<R$1> extends Result<infer T, any> ? T : AwaitedReturn<R$1>;
-type ErrOfReturn<R$1> = AwaitedReturn<R$1> extends Result<any, infer E> ? E : never;
+type AwaitedReturn<R> = Awaited<R>;
+type OkOfReturn<R> = AwaitedReturn<R> extends Result<infer T, any> ? T : AwaitedReturn<R>;
+type ErrOfReturn<R> = AwaitedReturn<R> extends Result<any, infer E> ? E : never;
 /**
  * Generator-based do-notation for `Result`.
  *
@@ -368,80 +22,10 @@ type ErrOfReturn<R$1> = AwaitedReturn<R$1> extends Result<any, infer E> ? E : ne
  * });
  * ```
  */
-declare function task<const Y, const R$1>(makeGenerator: () => AnyGenerator<Y, R$1, unknown>): Promise<Result<OkOfReturn<R$1>, ErrorOfYield<Y> | ErrOfReturn<R$1>>>;
-declare function task<const Y, const R$1, EThrown>(makeGenerator: () => AnyGenerator<Y, R$1, unknown>, onThrow: OnThrow<EThrown>): Promise<Result<OkOfReturn<R$1>, ErrorOfYield<Y> | ErrOfReturn<R$1> | EThrown>>;
+declare function task<const Y, const R>(makeGenerator: () => AnyGenerator<Y, R, unknown>): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R>>>;
+declare function task<const Y, const R, EThrown>(makeGenerator: () => AnyGenerator<Y, R, unknown>, onThrow: OnThrow<EThrown>): Promise<Result<OkOfReturn<R>, ErrorOfYield<Y> | ErrOfReturn<R> | EThrown>>;
 declare const gen: typeof task;
 //#endregion
-//#region src/errors.d.ts
-declare const ERR_INVALID_STATE: "ERR_INVALID_STATE";
-declare const ERR_TASK_YIELD_NOT_RESULT: "ERR_TASK_YIELD_NOT_RESULT";
-declare const ERR_MATCH_ON_OK: "ERR_MATCH_ON_OK";
-declare const ERR_UNWRAP_ON_ERR: "ERR_UNWRAP_ON_ERR";
-declare const ERR_UNWRAP_ERR_ON_OK: "ERR_UNWRAP_ERR_ON_OK";
-declare const ERR_EXPECT_OK: "ERR_EXPECT_OK";
-declare const ERR_EXPECT_ERR: "ERR_EXPECT_ERR";
-type ResultErrorCode = typeof ERR_INVALID_STATE | typeof ERR_TASK_YIELD_NOT_RESULT | typeof ERR_MATCH_ON_OK | typeof ERR_UNWRAP_ON_ERR | typeof ERR_UNWRAP_ERR_ON_OK | typeof ERR_EXPECT_OK | typeof ERR_EXPECT_ERR;
-declare class ResultError extends Error {
-  readonly code: ResultErrorCode;
-  readonly context?: string;
-  constructor(message: string, code: ResultErrorCode, context?: string);
-}
-declare class ResultTypeError extends TypeError {
-  readonly code: ResultErrorCode;
-  readonly context?: string;
-  constructor(message: string, code: ResultErrorCode, context?: string);
-}
-declare class InvalidResultStateError extends ResultError {
-  constructor(context?: string);
-}
-declare class TaskYieldNotResultError extends ResultTypeError {
-  readonly yieldedValue: unknown;
-  constructor(yieldedValue: unknown);
-}
-declare class MatchOnOkError extends ResultTypeError {
-  constructor();
-}
-declare class UnwrapOnErrError extends ResultTypeError {
-  readonly errorValue: unknown;
-  constructor(errorValue: unknown);
-}
-declare class UnwrapErrOnOkError extends ResultTypeError {
-  readonly okValue: unknown;
-  constructor(okValue: unknown);
-}
-declare class ExpectOkError extends ResultError {
-  readonly expectedMessage: string;
-  constructor(expectedMessage: string);
-}
-declare class ExpectErrError extends ResultError {
-  readonly expectedMessage: string;
-  constructor(expectedMessage: string);
-}
-//#endregion
-//#region src/core/fold.d.ts
-/**
- * Folds the Result into a single value by applying one of two functions.
- * The end of the pipe.
- *
- * This is the pipe operator equivalent of the `.fold()` instance method.
- */
-declare function fold<T, E, R$1>(handlers: {
-  ok: (val: T) => R$1;
-  err: (e: E) => R$1;
-}): (source: Result<T, E>) => R$1;
-//#endregion
-//#region src/core/foldAsync.d.ts
-/**
- * Async version of `fold`. Folds the Result into a single value asynchronously.
- * The end of the pipe.
- *
- * This is the async pipe operator equivalent of the `.fold()` instance method.
- */
-declare function foldAsync<T, E, R$1>(handlers: {
-  ok: (val: T) => Promise<R$1>;
-  err: (e: E) => Promise<R$1>;
-}): (source: Result<T, E>) => Promise<R$1>;
-//#endregion
 //#region src/core/unwrap.d.ts
 /**
  * Returns the value or throws an Error.
@@ -498,117 +82,6 @@ declare function expectResult<T, E>(result: Result<T, E>, message: string): T;
  */
 declare function expectErr<T, E>(result: Result<T, E>, message: string): E;
 //#endregion
-//#region src/core/and.d.ts
-/**
- * Combines two Results. Returns the second one only if the first is Ok.
- * Corresponds to Rust `and`.
- */
-declare function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E>;
-//#endregion
-//#region src/core/or.d.ts
-/**
- * Fallback to another Result if the first is Err.
- * Corresponds to Rust `or`.
- */
-declare function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F>;
-//#endregion
-//#region src/core/orElse.d.ts
-/**
- * Fallback with a function that returns a Result.
- * Corresponds to Rust `or_else`.
- */
-declare function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;
-//#endregion
-//#region src/core/mapOr.d.ts
-/**
- * Transforms the value or returns a default value.
- * Corresponds to Rust `map_or`.
- */
-declare function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U;
-//#endregion
-//#region src/core/mapOrElse.d.ts
-/**
- * Transforms the value or calculates a default value using a function.
- * Corresponds to Rust `map_or_else`.
- */
-declare function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U;
-//#endregion
-//#region src/core/sequence.d.ts
-/**
- * Combines a list of Results into a single Result of a list.
- * Short-circuits on the first Err.
- * Analogous to Rust `collect::<Result<Vec<_>, _>>()`.
- */
-declare function sequence<T, E>(results: readonly Result<T, E>[]): Result<T[], E>;
-/**
- * Alias for `sequence`.
- */
-declare function all<T, E>(results: readonly Result<T, E>[]): Result<T[], E>;
-//#endregion
-//#region src/core/sequenceRecord.d.ts
-type OkValueOf$1<R$1> = R$1 extends Result<infer T, any> ? T : never;
-type ErrValueOf$1<R$1> = R$1 extends Result<any, infer E> ? E : never;
-/**
- * Like `sequence`, but for Records/Objects.
- * Short-circuits on the first Err.
- */
-declare function sequenceRecord<const R$1 extends Record<string, Result<any, any>>>(record: R$1): Result<{ [K in keyof R$1]: OkValueOf$1<R$1[K]> }, ErrValueOf$1<R$1[keyof R$1]>>;
-//#endregion
-//#region src/core/collectFirstOkAsync.d.ts
-type CollectFirstOkAsyncInput$1 = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
-type ResolvedResult$1<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
-type OkValueOfInput$1<I> = ResolvedResult$1<I> extends Result<infer T, any> ? T : never;
-type ErrValueOfInput$1<I> = ResolvedResult$1<I> extends Result<any, infer E> ? E : never;
-/**
- * Async version of collectFirstOk.
- *
- * - Takes either already started Promises or "Thunks" (`() => Awaitable<Result<...>>`).
- * - Processes inputs strictly sequentially (like `for ... of` + `await`).
- * - Returns the first `Ok` and collects all errors if no `Ok` is found.
- */
-declare function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput$1[]>(inputs: Inputs): Promise<Result<OkValueOfInput$1<Inputs[number]>, ErrValueOfInput$1<Inputs[number]>[]>>;
-//#endregion
-//#region src/core/collectFirstOkParallelAsync.d.ts
-type CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
-type ResolvedResult<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
-type OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;
-type ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;
-/**
- * Parallel version of `collectFirstOkAsync`.
- *
- * - Starts all inputs immediately (Promises or Thunks).
- * - Returns the first `Ok` as soon as it is available.
- * - If no `Ok` is found, returns an `Err` with all error values (in input order).
- * - Rejections are treated as `ErrValue` (`caught as ErrValue`).
- * - If multiple inputs provide an `Ok`, the one that completes first wins.
- *   In case of simultaneous completion, the first observed result wins.
- * - If no `Ok` arrives and at least one input never settles, the Promise remains pending.
- */
-declare function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(inputs: Inputs): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>>;
-//#endregion
-//#region src/core/collectAllErrors.d.ts
-/**
- * Combines a list of Results.
- * Return Ok(values) only if all are Ok, otherwise Err([errors]).
- */
-declare function collectAllErrors<T, E>(results: readonly Result<T, E>[]): Result<T[], E[]>;
-//#endregion
-//#region src/core/partition.d.ts
-type OkValueOf<R$1> = R$1 extends Result<infer T, any> ? T : never;
-type ErrValueOf<R$1> = R$1 extends Result<any, infer E> ? E : never;
-/**
- * Partitions Results into Ok values and Err errors.
- */
-declare function partition<const Results extends readonly Result<any, any>[]>(results: Results): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>];
-//#endregion
-//#region src/core/flatten.d.ts
-/**
- * Flattens a nested Result.
- * Result<Result<T, E>, E> → Result<T, E>
- * Corresponds to Rust `flatten`.
- */
-declare function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E>;
-//#endregion
 //#region src/core/toPromise.d.ts
 /**
  * Converts a Result to a Promise.
@@ -651,12 +124,5 @@ declare function contains<T, E>(result: Result<T, E>, value: T): boolean;
  */
 declare function containsErr<T, E>(result: Result<T, E>, error: E): boolean;
 //#endregion
-//#region src/core/isResult.d.ts
-/**
- * Checks whether a value is a Result.
- * Pure function alternative for runtime checks.
- */
-declare function isResult(value: unknown): value is Result<any, any>;
-//#endregion
-export { AsyncOperatorFunction, type Awaitable, ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_STATE, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, Err, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchOnOkError, Ok, OperatorFunction, Result, ResultError, ResultErrorCode, ResultType, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, combine, contains, containsErr, err, expectErr, expectResult, filter, filterAsync, flatMap, flatMapAsync, flatten, fold, foldAsync, fromNullable, fromPromise, gen, isErr, isOk, isResult, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, ok, okIf, okIfLazy, or, orElse, partition, recover, recoverWith, sequence, sequenceRecord, swap, tap, tapAsync, task, toNullable, toPromise, tryCatch, tryCatchAsync, tryFn, tryMap, tryMapAsync, unwrap, unwrapErr, unwrapOr, unwrapOrDefault, unwrapOrElse, unwrapOrThrow, zip };
+export { AsyncOperatorFunction, Awaitable, ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, Err, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, Ok, OperatorFunction, Result, ResultError, ResultErrorCode, ResultType, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, combine, contains, containsErr, err, expectErr, expectResult, filter, filterAsync, flatMap, flatMapAsync, flatten, fold, foldAsync, fromNullable, fromPromise, fromThrowable, gen, isErr, isOk, isResult, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, matchTag, ok, okIf, okIfLazy, or, orElse, partition, recover, recoverWith, sequence, sequenceRecord, swap, tap, tapAsync, task, toNullable, toPromise, tryAsync, tryCatch, tryCatchAsync, tryFn, tryMap, tryMapAsync, unwrap, unwrapErr, unwrapOr, unwrapOrDefault, unwrapOrElse, unwrapOrThrow, zip };
 //# sourceMappingURL=index.d.mts.map