@shirudo/result 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,1033 @@
+//#region src/pipeable.d.ts
+type UnaryFunction<Input, Output> = (input: Input) => Output;
+type Awaitable<T> = T | Promise<T>;
+declare abstract class Pipeable {
+  pipe(): this;
+  pipe<B>(ab: UnaryFunction<this, B>): B;
+  pipe<B, C>(ab: UnaryFunction<this, B>, bc: UnaryFunction<B, C>): C;
+  pipe<B, C, D>(ab: UnaryFunction<this, B>, bc: UnaryFunction<B, C>, cd: UnaryFunction<C, D>): D;
+  pipe<A, B, C, D, E>(this: A, ab: UnaryFunction<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, B>): Promise<Awaited<B>>;
+  pipeAsync<A, B, C>(this: A, ab: UnaryFunction<this, B>, bc: UnaryFunction<Awaited<B>, C>): Promise<Awaited<C>>;
+  pipeAsync<A, B, C, D>(this: A, ab: UnaryFunction<this, B>, bc: UnaryFunction<Awaited<B>, C>, cd: UnaryFunction<Awaited<C>, D>): Promise<Awaited<D>>;
+  pipeAsync<A, B, C, D, E>(this: A, ab: UnaryFunction<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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<this, 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/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 any return type, e.g. string messages).
+ *
+ * - `.when(Ctor, handler)` matched via `instanceof`
+ * - `.whenGuard(guard, handler)` matched via type guard
+ * - `.run()` is only allowed once all error cases are handled (`E` is reduced to `never`)
+ */
+declare class ErrorMatchBuilder<E, R$1> {
+  #private;
+  constructor(error: unknown, matched?: boolean, value?: unknown);
+  when<C extends Ctor<any>, 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: any) => 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 that always returns a `Result`.
+ *
+ * Handlers may:
+ * - return a `Result` (returned directly)
+ * - return an error value (automatically wrapped to `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<any>, 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>;
+}
+type ErrCase = {
+  readonly kind: 'ctor';
+  readonly ctor: Ctor<any>;
+  readonly handler: (error: any) => unknown;
+} | {
+  readonly kind: 'val';
+  readonly value: unknown;
+  readonly handler: (error: any) => unknown;
+};
+declare const HAS_OK: unique symbol;
+type HasOk = {
+  readonly [HAS_OK]: true;
+};
+type WithOk<T, E, R$1> = ResultMatchBuilder<T, E, R$1> & HasOk;
+type IsUnion<T, U = T> = T extends any ? ([U] extends [T] ? false : true) : never;
+type ExcludeIfLiteral<E, V> = IsUnion<V> extends true ? E : V extends string ? string extends V ? E : Exclude<E, V> : V extends number ? number extends V ? E : Exclude<E, V> : V extends boolean ? boolean extends V ? E : Exclude<E, V> : V extends bigint ? bigint extends V ? E : Exclude<E, V> : V extends symbol ? symbol extends V ? E : Exclude<E, V> : Exclude<E, V>;
+/**
+ * Universal matcher for `Result` (Ok + Err in a single chain).
+ *
+ * - `.err(Ctor, handler)` matched via `instanceof`
+ * - `.errVal(value, handler)` matched via `Object.is`
+ * - `.ok(handler)` defines the success branch
+ * - `.run()` is only allowed after `.ok()` is set
+ *
+ * Lazy: if the Result is `Ok`, Err cases are not evaluated in `.run()`.
+ */
+declare class ResultMatchBuilder<T, E, R$1> {
+  #private;
+  constructor(result: Result<T, E>, errCases?: readonly ErrCase[], okHandler?: (value: T) => unknown);
+  static fromResult<T, E>(result: Result<T, E>): ResultMatchBuilder<T, E, never>;
+  err<C extends Ctor<any>, R1>(this: ResultMatchBuilder<T, E, R$1>, ctor: C, handler: (error: InstanceType<C>) => R1): ResultMatchBuilder<T, Exclude<E, InstanceType<C>>, R$1 | R1>;
+  err<C extends Ctor<any>, R1>(this: WithOk<T, E, R$1>, ctor: C, handler: (error: InstanceType<C>) => R1): WithOk<T, Exclude<E, InstanceType<C>>, R$1 | R1>;
+  errVal<const V, R1>(this: ResultMatchBuilder<T, E, R$1>, value: V, handler: (error: V) => R1): ResultMatchBuilder<T, ExcludeIfLiteral<E, V>, R$1 | R1>;
+  errVal<const V, R1>(this: WithOk<T, E, R$1>, value: V, handler: (error: V) => R1): WithOk<T, ExcludeIfLiteral<E, V>, R$1 | R1>;
+  ok<R1>(handler: (value: T) => R1): WithOk<T, E, R$1 | R1>;
+  run(this: WithOk<T, E, R$1>): R$1;
+}
+//#endregion
+//#region src/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 Ok<T> = {
+  readonly _tag: 'Ok';
+  readonly value: T;
+};
+type Err<E> = {
+  readonly _tag: 'Err';
+  readonly error: E;
+};
+type ResultType<T, E> = Ok<T> | Err<E>;
+declare class Result<T, E> extends Pipeable {
+  #private;
+  private constructor();
+  /**
+   * Creates an Ok Result with the given value.
+   *
+   * **Note**: `null` and `undefined` are allowed as values.
+   * If you want to convert `null`/`undefined` to an Err, use `fromNullable()`.
+   *
+   * @param value The value for the Ok Result
+   * @returns An Ok Result with the given value
+   *
+   * @example
+   * ```ts
+   * const result = Result.ok(42);
+   * const nullResult = Result.ok(null); // Allowed!
+   * ```
+   */
+  static ok<T, E = never>(value: T): Result<T, E>;
+  /**
+   * Creates an Err Result with the given error.
+   *
+   * **Note**: `null` and `undefined` are allowed as errors.
+   *
+   * @param error The error for the Err Result
+   * @returns An Err Result with the given error
+   *
+   * @example
+   * ```ts
+   * const result = Result.err('error message');
+   * const nullError = Result.err(null); // Allowed!
+   * ```
+   */
+  static err<E, T = never>(error: E): Result<T, E>;
+  /**
+   * Converts `null | undefined` to `Err`, everything else to `Ok`.
+   *
+   * **Type Safety**: The type assertion `as NonNullable<T>` is safe,
+   * as the runtime check guarantees that the value is not null/undefined.
+   *
+   * @param value The value to check
+   * @param error The error to use if value is null/undefined
+   * @returns An Ok Result with the NonNullable value, or an Err Result with the error
+   *
+   * @example
+   * ```ts
+   * Result.fromNullable(user, 'User not found')
+   * // Ok(user) or Err('User not found')
+   * ```
+   */
+  static fromNullable<T, E>(value: T, error: E): Result<NonNullable<T>, E>;
+  /**
+   * Converts a Promise to a Result-Promise.
+   * Exceptions are converted to Err.
+   *
+   * This static method delegates to the standalone `fromPromise()` function.
+   *
+   * @example
+   * ```ts
+   * const result = await Result.fromPromise(fetch('/api/user'));
+   * // Ok(response) or Err(error)
+   *
+   * // With custom error mapper
+   * const result = await Result.fromPromise(
+   *     fetch('/api/user'),
+   *     (e) => `Network error: ${e}`
+   * );
+   * ```
+   */
+  static fromPromise<T>(promise: Promise<T>): Promise<Result<T, unknown>>;
+  static fromPromise<T, E>(promise: Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>>;
+  /**
+   * Executes a function and catches exceptions.
+   *
+   * @example
+   * ```ts
+   * const result = Result.try(() => JSON.parse(input));
+   * // Ok(parsed) or Err(SyntaxError)
+   * ```
+   */
+  static try<T>(fn: () => T): Result<T, unknown>;
+  /**
+   * Checks if the Result is Ok.
+   *
+   * @returns `true` if the Result is Ok (and narrows the type)
+   *
+   * @example
+   * ```ts
+   * if (result.isOk()) {
+   *   const value: T = result.value; // TypeScript knows that value is defined
+   * }
+   * ```
+   */
+  isOk(): this is Result<T, E> & {
+    readonly value: T;
+    readonly error: undefined;
+  };
+  /**
+   * Checks if the Result is Err.
+   *
+   * @returns `true` if the Result is Err (and narrows the type)
+   *
+   * @example
+   * ```ts
+   * if (result.isErr()) {
+   *   const error: E = result.error; // TypeScript knows that error is defined
+   * }
+   * ```
+   */
+  isErr(): this is Result<T, E> & {
+    readonly value: undefined;
+    readonly error: E;
+  };
+  get value(): T | undefined;
+  get error(): E | undefined;
+  /**
+   * Returns the value, guaranteed to be defined after `isOk()` check.
+   * This method provides better type narrowing than the `value` getter.
+   *
+   * ⚠️ **Warning**: This method throws an Error if called on an Err result.
+   * Use this method only after a type guard (`if (result.isOk())`).
+   * For a safer alternative with a custom message, use `expect()`.
+   *
+   * @throws {Error} If called on an Err result
+   *
+   * @example
+   * ```ts
+   * if (result.isOk()) {
+   *   const value = result.unwrap(); // Type is T, not T | undefined
+   * }
+   * ```
+   */
+  unwrap(): T;
+  /**
+   * Returns the error, guaranteed to be defined after `isErr()` check.
+   * This method provides better type narrowing than the `error` getter.
+   *
+   * ⚠️ **Warning**: This method throws an Error if called on an Ok result.
+   * Use this method only after a type guard (`if (result.isErr())`).
+   * For a safer alternative with a custom message, use `expectErr()`.
+   *
+   * @throws {Error} If called on an Ok result
+   *
+   * @example
+   * ```ts
+   * if (result.isErr()) {
+   *   const error = result.unwrapErr(); // Type is E, not E | undefined
+   * }
+   * ```
+   */
+  unwrapErr(): E;
+  /**
+   * Returns the value with a custom error message if the result is Err.
+   * Similar to `unwrap()`, but allows you to provide a custom error message.
+   *
+   * ⚠️ **Warning**: This method throws an Error if called on an Err result.
+   * Use this method only if you are sure the Result is Ok,
+   * or if you need a meaningful error message.
+   *
+   * @param message Custom error message to throw if result is Err
+   * @returns The value if result is Ok
+   * @throws {Error} If called on an Err result with the provided message
+   *
+   * @example
+   * ```ts
+   * const result = fetchUser(id);
+   * const user = result.expect('User should exist'); // Throws with custom message if Err
+   * ```
+   */
+  expect(message: string): T;
+  /**
+   * Returns the error with a custom error message if the result is Ok.
+   * Similar to `unwrapErr()`, but allows you to provide a custom error message.
+   *
+   * ⚠️ **Warning**: This method throws an Error if called on an Ok result.
+   * Use this method only if you are sure the Result is Err,
+   * or if you need a meaningful error message.
+   *
+   * @param message Custom error message to throw if result is Ok
+   * @returns The error if result is Err
+   * @throws {Error} If called on an Ok result with the provided message
+   *
+   * @example
+   * ```ts
+   * const result = validateInput(input);
+   * if (result.isErr()) {
+   *   const error = result.expectErr('Validation should have failed'); // Throws if Ok
+   * }
+   * ```
+   */
+  expectErr(message: string): E;
+  unwrapOr<D = T>(defaultValue: D): T | D;
+  /**
+   * Converts the Result to a Promise.
+   * Ok → resolves with the value, Err → rejects with the error
+   *
+   * This instance method delegates to the standalone `toPromise()` function.
+   *
+   * @returns A Promise that resolves with the value if Ok, or rejects with the error if Err
+   *
+   * @example
+   * ```ts
+   * const result = ok(42);
+   * const promise = result.toPromise();
+   * const value = await promise; // 42
+   *
+   * const errResult = err('error');
+   * try {
+   *   await errResult.toPromise();
+   * } catch (error) {
+   *   console.log(error); // 'error'
+   * }
+   * ```
+   */
+  toPromise(): Promise<T>;
+  /**
+   * Converts the Result to `T | null`.
+   * Ok → returns the value, Err → returns null
+   *
+   * This instance method delegates to the standalone `toNullable()` function.
+   *
+   * @returns The value if Ok, or null if Err
+   *
+   * @example
+   * ```ts
+   * const result = ok(42);
+   * const value = result.toNullable(); // 42
+   *
+   * const errResult = err('error');
+   * const nullValue = errResult.toNullable(); // null
+   * ```
+   */
+  toNullable(): T | null;
+  /**
+   * 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<Result<T, E>, T, unknown>;
+  /**
+   * Universal pattern matcher for Ok + Err cases.
+   *
+   * Use this to exhaustively match on both success and error cases with type-based
+   * and value-based pattern matching.
+   *
+   * @example
+   * ```ts
+   * const message = result
+   *   .match()
+   *   .err(NetworkError, e => `Network: ${e.message}`)
+   *   .err(ValidationError, e => `Validation: ${e.message}`)
+   *   .ok(val => `Success: ${val}`)
+   *   .run();
+   * ```
+   */
+  match(): ResultMatchBuilder<T, E, never>;
+  /**
+   * Matches on the Err value via `.when(...)` chain.
+   *
+   * Note: For type safety reasons, `.matchErr()` can only be called on a Result that has already been narrowed to `Err`,
+   * e.g., inside `if (result.isErr()) { ... }`.
+   *
+   * @example
+   * ```ts
+   * if (result.isErr()) {
+   *   const message = result
+   *     .matchErr()
+   *     .when(IOError, () => 'IO error')
+   *     .when(ParseError, () => 'Parse error')
+   *     .otherwise(e => `Other: ${e}`);
+   * }
+   * ```
+   */
+  matchErr(this: Result<T, E> & {
+    readonly error: E;
+  }): ErrorMatchBuilder<E, never>;
+  matchErr(this: Result<T, E>): never;
+  /**
+   * Matches on the Err value, but normalizes every branch to a `Result`:
+   * - Handlers may return a `Result` (returned directly)
+   * - or an error value (wrapped to `Err(error)`)
+   */
+  matchErrResult(): ErrMatchBuilder<T, E, never, never>;
+  /**
+   * @deprecated Use `.match()` instead. Will be removed in next major version.
+   */
+  pattern(): ResultMatchBuilder<T, E, never>;
+  /**
+   * @deprecated Use `.match()` instead. Will be removed in next major version.
+   */
+  switch(): ResultMatchBuilder<T, E, never>;
+  /**
+   * Folds the Result into a single value by applying one of two functions.
+   *
+   * This is a direct method equivalent to the `match` pipe operator.
+   * Use this when you want to handle both Ok and Err cases and return a single value.
+   *
+   * @param onOk Function to apply if the Result is Ok
+   * @param onErr Function to apply if the Result is Err
+   * @returns The result of applying the appropriate function
+   *
+   * @example
+   * ```ts
+   * const result = ok(42);
+   * const message = result.fold(
+   *     val => `Success: ${val}`,
+   *     err => `Error: ${err}`
+   * );
+   * // message = "Success: 42"
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Works with discriminated unions
+   * const result: Result<string, number> = err(404);
+   * const response = result.fold(
+   *     data => ({ success: true as const, data }),
+   *     code => ({ success: false as const, code })
+   * );
+   * // response: { success: true; data: string } | { success: false; code: number }
+   * ```
+   */
+  fold<R1, R2 = R1>(onOk: (value: T) => R1, onErr: (error: E) => R2): R1 | R2;
+  /**
+   * Returns the Result as a discriminated union (`{ _tag: 'Ok', value } | { _tag: 'Err', error }`).
+   * Useful for libraries like `ts-pattern` that match on plain object unions.
+   */
+  toUnion(): ResultType<T, E>;
+  /**
+   * Serializes the Result into a simple object format.
+   * Preserves the original types.
+   */
+  serialize(): {
+    isSuccess: boolean;
+    data?: T;
+    error?: E;
+  };
+  /**
+   * Serializes the Result into a user-friendly format.
+   * Converts errors to readable strings.
+   */
+  toUserFriendly(): {
+    isSuccess: boolean;
+    data?: T;
+    error?: string;
+  };
+}
+declare const ok: typeof Result.ok;
+declare const err: typeof Result.err;
+/**
+ * Helper for conditional Result creation.
+ * Avoids type inference issues with ternary operators.
+ *
+ * @example
+ * ```ts
+ * const result = okIf(value > 5, value, 'too small');
+ * // instead of: value > 5 ? ok(value) : err('too small')
+ * ```
+ */
+declare function okIf<T, E>(condition: boolean, okValue: T, errValue: E): Result<T, E>;
+/**
+ * Helper for conditional Result creation with lazy evaluation.
+ * Evaluates values only when they are needed.
+ *
+ * @example
+ * ```ts
+ * const result = okIfLazy(
+ *     value > 5,
+ *     () => expensiveComputation(value),
+ *     () => 'too small'
+ * );
+ * ```
+ */
+declare function okIfLazy<T, E>(condition: boolean, okFn: () => T, errFn: () => E): Result<T, E>;
+//#endregion
+//#region src/gen.d.ts
+type AnyGenerator = Generator<any, any, unknown> | AsyncGenerator<any, any, unknown>;
+type YieldOf<G> = G extends Generator<infer Y, any, any> ? Y : G extends AsyncGenerator<infer Y, any, any> ? Y : never;
+type ReturnOf<G> = G extends Generator<any, infer R, any> ? R : G extends AsyncGenerator<any, infer R, any> ? R : never;
+type ErrorOfYield<Y> = Y extends Result<any, infer E> ? E : never;
+type ErrorOfGenerator<G> = ErrorOfYield<YieldOf<G>>;
+type OnThrow<E> = (error: unknown) => E;
+type AwaitedReturnOf<G> = Awaited<ReturnOf<G>>;
+type OkOfReturn<G> = AwaitedReturnOf<G> extends Result<infer T, any> ? T : AwaitedReturnOf<G>;
+type ErrOfReturn<G> = AwaitedReturnOf<G> extends Result<any, infer E> ? E : never;
+/**
+ * Generator-based do-notation for `Result`.
+ *
+ * Usage:
+ * ```ts
+ * const out = await task(async function* () {
+ *   const user = yield* await fromPromise(findUser(1));
+ *   const email = yield* validate(user.email);
+ *   return email;
+ * });
+ * ```
+ */
+declare function task<const G extends AnyGenerator>(makeGenerator: () => G): Promise<Result<OkOfReturn<G>, ErrorOfGenerator<G> | ErrOfReturn<G>>>;
+declare function task<const G extends AnyGenerator, EThrown>(makeGenerator: () => G, onThrow: OnThrow<EThrown>): Promise<Result<OkOfReturn<G>, ErrorOfGenerator<G> | ErrOfReturn<G> | EThrown>>;
+declare const gen: typeof task;
+//#endregion
+//#region src/operators/map.d.ts
+/**
+ * Transforms the value (Ok case).
+ * Equivalent to Rust `map`.
+ */
+declare function map<T, E, U>(project: (value: T) => U): (source: Result<T, E>) => Result<U, E>;
+//#endregion
+//#region src/operators/mapErr.d.ts
+/**
+ * Transforms the error (Err case).
+ * Equivalent to Rust `map_err`.
+ */
+declare function mapErr<T, E, F>(project: (error: E) => F): (source: Result<T, E>) => Result<T, F>;
+//#endregion
+//#region src/operators/mapBoth.d.ts
+/**
+ * Transforms both the Ok value and the Err error.
+ * Equivalent 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/operators/flatMap.d.ts
+/**
+ * Chains another operation that returns a Result.
+ * Equivalent to Rust `and_then` or JS `flatMap`.
+ */
+declare function flatMap<T, E, U, E2 = E>(project: (value: T) => Result<U, E2>): (source: Result<T, E>) => Result<U, E | E2>;
+//#endregion
+//#region src/operators/tap.d.ts
+/**
+ * Executes a side effect (logging, debugging) without changing the Result.
+ * Equivalent to Rust `inspect` / `inspect_err`.
+ */
+declare function tap<T, E>(observer: {
+  ok?: (val: T) => void;
+  err?: (e: E) => void;
+}): <SourceT extends T, SourceE extends E>(source: Result<SourceT, SourceE>) => Result<SourceT, SourceE>;
+//#endregion
+//#region src/operators/filter.d.ts
+/**
+ * Checks a predicate. If false, the Result becomes Err.
+ * Partially equivalent to Rust `filter`.
+ */
+declare function filter<T, E>(predicate: (val: T) => boolean, errorFn: () => E): (source: Result<T, E>) => Result<T, E>;
+//#endregion
+//#region src/operators/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;
+/**
+ * @deprecated Use `fold` instead. Will be removed in next major version.
+ */
+declare const match: typeof fold;
+//#endregion
+//#region src/operators/tryCatch.d.ts
+/**
+ * Executes a function and catches exceptions.
+ * Converts exceptions into Result<E>.
+ * Equivalent to Rust `Result::from` for fallible operations.
+ */
+declare function tryCatch<T, E = unknown>(fn: () => T, errorMapper?: (error: unknown) => E): <SourceT, SourceE>(source: Result<SourceT, SourceE>) => Result<T | SourceT, E | SourceE>;
+//#endregion
+//#region src/operators/tryMap.d.ts
+/**
+ * Like `map`, but catches exceptions and turns them into 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/operators/recover.d.ts
+/**
+ * Recover: turns Err into Ok(defaultValue).
+ * Result is guaranteed Ok → error type becomes `never`.
+ */
+declare function recover<T, E, D = T>(defaultValue: D): (source: Result<T, E>) => Result<T | D, never>;
+/**
+ * Like `recover`, but computes the default value from the error.
+ */
+declare function recoverWith<T, E, D = T>(fn: (error: E) => D): (source: Result<T, E>) => Result<T | D, never>;
+//#endregion
+//#region src/operators-async/mapAsync.d.ts
+/**
+ * Async version of map.
+ */
+declare function mapAsync<T, E, U>(project: (value: T) => Promise<U>): (source: Result<T, E>) => Promise<Result<Awaited<U>, E>>;
+//#endregion
+//#region src/operators-async/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/operators-async/flatMapAsync.d.ts
+/**
+ * Async version of flatMap.
+ * Allows different error types in the projected Result.
+ */
+declare function flatMapAsync<T, E, U, E2 = E>(project: (value: T) => Promise<Result<U, E2>>): (source: Result<T, E>) => Promise<Result<U, E | E2>>;
+//#endregion
+//#region src/operators-async/tapAsync.d.ts
+/**
+ * Async version of tap.
+ */
+declare function tapAsync<T, E>(observer: {
+  ok?: (val: T) => Promise<void>;
+  err?: (e: E) => Promise<void>;
+}): <SourceT extends T, SourceE extends E>(source: Result<SourceT, SourceE>) => Promise<Result<SourceT, SourceE>>;
+//#endregion
+//#region src/operators-async/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/operators-async/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>;
+/**
+ * @deprecated Use `foldAsync` instead. Will be removed in next major version.
+ */
+declare const matchAsync: typeof foldAsync;
+//#endregion
+//#region src/operators-async/tryCatchAsync.d.ts
+/**
+ * Async version of tryCatch.
+ */
+declare function tryCatchAsync<T, E = unknown>(fn: () => Promise<T>, errorMapper?: (error: unknown) => E): <SourceT, SourceE>(source: Result<SourceT, SourceE>) => Promise<Result<T, E | SourceE>>;
+//#endregion
+//#region src/operators-async/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/unwrap/unwrap.d.ts
+/**
+ * Returns the value or throws an Error.
+ * Equivalent to Rust `unwrap`.
+ */
+declare function unwrap<T, E>(result: Result<T, E>): T;
+//#endregion
+//#region src/unwrap/unwrapOr.d.ts
+/**
+ * Returns the value or a default value.
+ * Pure function alternative to the instance method.
+ */
+declare function unwrapOr<T, E, D = T>(result: Result<T, E>, defaultValue: D): T | D;
+//#endregion
+//#region src/unwrap/unwrapOrElse.d.ts
+/**
+ * Returns the value or computes a default value with a function.
+ * Equivalent to Rust `unwrap_or_else`.
+ */
+declare function unwrapOrElse<T, E, D = T>(result: Result<T, E>, fn: (error: E) => D): T | D;
+//#endregion
+//#region src/unwrap/unwrapOrDefault.d.ts
+/**
+ * Alias for `unwrapOr`.
+ * Equivalent to Rust `unwrap_or_default` (with an explicit default value).
+ */
+declare function unwrapOrDefault<T, E, D = T>(result: Result<T, E>, defaultValue: D): T | D;
+//#endregion
+//#region src/unwrap/unwrapOrThrow.d.ts
+/**
+ * Returns the value or throws the original Err value (not wrapped).
+ * Useful to keep `Error` instances with stack traces.
+ */
+declare function unwrapOrThrow<T, E>(result: Result<T, E>): T;
+//#endregion
+//#region src/unwrap/unwrapErr.d.ts
+/**
+ * Returns the error or throws an Error.
+ * Equivalent to Rust `unwrap_err`.
+ */
+declare function unwrapErr<T, E>(result: Result<T, E>): E;
+//#endregion
+//#region src/unwrap/expectResult.d.ts
+/**
+ * Returns the value or throws an Error with a custom message.
+ * Equivalent to Rust `expect`.
+ */
+declare function expectResult<T, E>(result: Result<T, E>, message: string): T;
+//#endregion
+//#region src/unwrap/expectErr.d.ts
+/**
+ * Returns the error or throws an Error with a custom message.
+ * Equivalent to Rust `expect_err`.
+ */
+declare function expectErr<T, E>(result: Result<T, E>, message: string): E;
+//#endregion
+//#region src/combinators/and.d.ts
+/**
+ * Combines two Results. Returns the second only if the first is Ok.
+ * Equivalent to Rust `and`.
+ */
+declare function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E>;
+//#endregion
+//#region src/combinators/or.d.ts
+/**
+ * Fallback to another Result when the first is Err.
+ * Equivalent to Rust `or`.
+ */
+declare function or<T, E, T2 = T, E2 = E>(result: Result<T, E>, other: Result<T2, E2>): Result<T | T2, E2>;
+//#endregion
+//#region src/combinators/orElse.d.ts
+/**
+ * Fallback using a function that returns a Result.
+ * Equivalent to Rust `or_else`.
+ */
+declare function orElse<T, E, T2 = T, E2 = E>(result: Result<T, E>, fn: (error: E) => Result<T2, E2>): Result<T | T2, E2>;
+//#endregion
+//#region src/combinators/mapOr.d.ts
+/**
+ * Transforms the value or returns a default value.
+ * Equivalent to Rust `map_or`.
+ */
+declare function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U;
+//#endregion
+//#region src/combinators/mapOrElse.d.ts
+/**
+ * Transforms the value or computes a default value with a function.
+ * Equivalent 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/combinators/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/combinators/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/collections/sequence.d.ts
+type ResultLike$1<T, E> = {
+  isOk(): boolean;
+  isErr(): boolean;
+  readonly value: T | undefined;
+  readonly error: E | undefined;
+};
+type OkValueOf$3<R$1> = R$1 extends ResultLike$1<infer T, any> ? T : never;
+type ErrValueOf$3<R$1> = R$1 extends ResultLike$1<any, infer E> ? E : never;
+/**
+ * Combines a list of Results into a Result of a list.
+ * Short-circuits on the first Err.
+ * Analogous to Rust `collect::<Result<Vec<_>, _>>()`.
+ */
+declare function sequence<const Results extends readonly ResultLike$1<any, any>[]>(results: Results): Result<Array<OkValueOf$3<Results[number]>>, ErrValueOf$3<Results[number]>>;
+/**
+ * Alias for `sequence`.
+ */
+declare function all<const Results extends readonly ResultLike$1<any, any>[]>(results: Results): Result<Array<OkValueOf$3<Results[number]>>, ErrValueOf$3<Results[number]>>;
+//#endregion
+//#region src/collections/sequenceRecord.d.ts
+type ResultLike<T, E> = {
+  isOk(): boolean;
+  isErr(): boolean;
+  readonly value: T | undefined;
+  readonly error: E | undefined;
+};
+type OkValueOf$2<R$1> = R$1 extends ResultLike<infer T, any> ? T : never;
+type ErrValueOf$2<R$1> = R$1 extends ResultLike<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, ResultLike<any, any>>>(record: R$1): Result<{ [K in keyof R$1]: OkValueOf$2<R$1[K]> }, ErrValueOf$2<R$1[keyof R$1]>>;
+//#endregion
+//#region src/collections/collectFirstOk.d.ts
+/**
+ * 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<T, E>(results: readonly (Result<T, E> | Result<T, never> | Result<never, E>)[]): Result<T, E[]>;
+//#endregion
+//#region src/collections/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.
+ *
+ * - Accepts already-started promises or "thunks" (`() => Awaitable<Result<...>>`).
+ * - Processes inputs strictly sequentially (like `for ... of` + `await`).
+ * - Returns the first `Ok` and collects all errors when 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/collections/collectFirstOkRaceAsync.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/race variant 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).
+ * - **Note**: There is no cancellation logic. All inputs keep running even after the first `Ok` is found.
+ */
+declare function collectFirstOkRaceAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(inputs: Inputs): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>>;
+//#endregion
+//#region src/collections/collectAllErrors.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;
+/**
+ * Combines a list of Results.
+ * Returns Ok(values) only if all are Ok, otherwise Err([errors]).
+ */
+declare function collectAllErrors<const Results extends readonly Result<any, any>[]>(results: Results): Result<Array<OkValueOf$1<Results[number]>>, Array<ErrValueOf$1<Results[number]>>>;
+//#endregion
+//#region src/collections/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/collections/flatten.d.ts
+/**
+ * Flacht ein nested Result ab.
+ * Result<Result<T, E>, E> → Result<T, E>
+ * Entspricht Rust `flatten`.
+ */
+declare function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E>;
+//#endregion
+//#region src/conversions/fromPromise.d.ts
+/**
+ * Converts a Promise to a Result-Promise.
+ * Exceptions are converted to Err.
+ *
+ * @param promise The Promise to convert
+ * @param errorMapper Optional function to map errors to a specific type
+ * @returns A Promise that resolves to an Ok Result with the value, or an Err Result with the error
+ *
+ * @example
+ * ```ts
+ * const result = await fromPromise(fetch('/api/user'));
+ * // Ok(response) or Err(error)
+ *
+ * // With custom error mapper
+ * const result = await fromPromise(
+ *     fetch('/api/user'),
+ *     (e) => `Network error: ${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>>;
+//#endregion
+//#region src/conversions/fromNullable.d.ts
+/**
+ * Converts `null | undefined` to `Err`, everything else to `Ok`.
+ *
+ * **Type Safety**: The type assertion `as NonNullable<T>` is safe,
+ * as the runtime check guarantees that the value is not null/undefined.
+ *
+ * @param value The value to check
+ * @param error The error to use if value is null/undefined
+ * @returns An Ok Result with the NonNullable value, or an Err Result with the error
+ *
+ * @example
+ * ```ts
+ * fromNullable(user, 'User not found')
+ * // Ok(user) or Err('User not found')
+ * ```
+ */
+declare function fromNullable<T, E>(value: T, error: E): Result<NonNullable<T>, E>;
+//#endregion
+//#region src/conversions/try.d.ts
+/**
+ * Executes a function and catches exceptions.
+ *
+ * @param fn The function to execute
+ * @returns An Ok Result with the return value, or an Err Result with the caught exception
+ *
+ * @example
+ * ```ts
+ * const result = tryFn(() => JSON.parse(input));
+ * // Ok(parsed) or Err(SyntaxError)
+ * ```
+ */
+declare function tryFn<T>(fn: () => T): Result<T, unknown>;
+//#endregion
+//#region src/conversions/toPromise.d.ts
+/**
+ * Converts a Result to a Promise.
+ * Ok → resolves with the value, Err → rejects with the error
+ *
+ * @param result The Result to convert
+ * @returns A Promise that resolves with the value if Ok, or rejects with the error if Err
+ *
+ * @example
+ * ```ts
+ * const result = ok(42);
+ * const promise = toPromise(result);
+ * const value = await promise; // 42
+ * ```
+ */
+declare function toPromise<T, E>(result: Result<T, E>): Promise<T>;
+//#endregion
+//#region src/conversions/toNullable.d.ts
+/**
+ * Converts a Result to `T | null`.
+ * Ok → returns the value, Err → returns null
+ *
+ * @param result The Result to convert
+ * @returns The value if Ok, or null if Err
+ *
+ * @example
+ * ```ts
+ * const result = ok(42);
+ * const value = toNullable(result); // 42
+ *
+ * const errResult = err('error');
+ * const nullValue = toNullable(errResult); // null
+ * ```
+ */
+declare function toNullable<T, E>(result: Result<T, E>): T | null;
+//#endregion
+//#region src/utils/isOk.d.ts
+/**
+ * Checks whether a Result is Ok.
+ * Pure function alternative to the instance method.
+ */
+declare function isOk<T, E>(result: Result<T, E>): result is Result<T, E> & {
+  readonly value: T;
+  readonly error: undefined;
+};
+//#endregion
+//#region src/utils/isErr.d.ts
+/**
+ * Checks whether a Result is Err.
+ * Pure function alternative to the instance method.
+ */
+declare function isErr<T, E>(result: Result<T, E>): result is Result<T, E> & {
+  readonly value: undefined;
+  readonly error: E;
+};
+//#endregion
+//#region src/utils/contains.d.ts
+/**
+ * Checks whether the Result contains a specific value.
+ * Equivalent to Rust `contains`.
+ */
+declare function contains<T, E>(result: Result<any, E>, value: T): boolean;
+//#endregion
+//#region src/utils/containsErr.d.ts
+/**
+ * Checks whether the Result contains a specific error.
+ * Analogous to `contains` for the Err case.
+ */
+declare function containsErr<T, E>(result: Result<T, E>, error: E): boolean;
+//#endregion
+//#region src/utils/isResult.d.ts
+declare function isResult(value: unknown): value is Result<any, any>;
+//#endregion
+export { AsyncOperatorFunction, type Awaitable, Err, Ok, OperatorFunction, Result, ResultType, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkRaceAsync, 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 };
+//# sourceMappingURL=index.d.cts.map