@shirudo/result 0.0.1 → 0.0.3

package/dist/index.d.mts

@@ -1,896 +1,561 @@
-//#region src/pipeable.d.ts
+//#region src/core/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;
+  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<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>>;
+  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/matcher.d.ts
+//#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 any return type, e.g. string messages).
+ * Matcher für Err-Values (liefert einen beliebigen Return-Type, z.B. 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`)
+ * - `.whenGuard(guard, handler)` matched via Type-Guard
+ * - `.run()` ist nur erlaubt, wenn alle Error-Cases behandelt wurden (`E` wurde zu `never` reduziert)
  */
 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>;
+  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: any) => R2): R$1 | R2;
+  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 that always returns a `Result`.
+ * Matcher für `Result`-Errors, der immer wieder ein `Result` zurückgibt.
  *
- * Handlers may:
- * - return a `Result` (returned directly)
- * - return an error value (automatically wrapped to `Err(error)`)
+ * Handler dürfen:
+ * - ein `Result` zurückgeben (wird direkt returned)
+ * - einen Error-Wert zurückgeben (wird automatisch zu `Err(error)` gewrappt)
  */
 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>>;
+  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>;
 }
-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;
+//#region src/core/map.d.ts
 /**
- * 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`.
+ * Transformiert den Wert (Ok-Fall).
+ * Entspricht 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
+//#region src/core/mapErr.d.ts
 /**
- * Transforms the error (Err case).
- * Equivalent to Rust `map_err`.
+ * Transformiert den Fehler (Err-Fall).
+ * Entspricht 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
+//#region src/core/mapBoth.d.ts
 /**
- * Transforms both the Ok value and the Err error.
- * Equivalent to FP `bimap` / `mapBoth`.
+ * Transformiert sowohl den Ok-Wert als auch den Err-Fehler.
+ * Entspricht 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`.
+ * Alias für `mapBoth`.
  */
 declare const bimap: typeof mapBoth;
 //#endregion
-//#region src/operators/flatMap.d.ts
+//#region src/core/flatMap.d.ts
 /**
- * Chains another operation that returns a Result.
- * Equivalent to Rust `and_then` or JS `flatMap`.
+ * Verkettet eine weitere Operation, die ein Result zurückgibt.
+ * Entspricht Rust `and_then` oder JS `flatMap`.
  */
-declare function flatMap<T, E, U, E2 = E>(project: (value: T) => Result<U, E2>): (source: Result<T, E>) => Result<U, E | E2>;
+declare function flatMap<T, E, U>(project: (value: T) => Result<U, E>): (source: Result<T, E>) => Result<U, E>;
 //#endregion
-//#region src/operators/tap.d.ts
+//#region src/core/zip.d.ts
 /**
- * Executes a side effect (logging, debugging) without changing the Result.
- * Equivalent to Rust `inspect` / `inspect_err`.
+ * Kombiniert zwei Results zu einem Result eines Tupels.
+ * Short-circuits beim ersten Err (links vor rechts).
+ */
+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>;
+/**
+ * Kombiniert zwei Results und sammelt Fehler ein.
+ * - Ok nur wenn beide Ok sind
+ * - Err([errors]) wenn mindestens ein Err ist (links vor rechts)
+ */
+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
+/**
+ * Führt einen Seiteneffekt aus (Logging, Debugging), ohne das Result zu ändern.
+ * Entspricht 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>;
+}): (source: Result<T, E>) => Result<T, E>;
 //#endregion
-//#region src/operators/filter.d.ts
+//#region src/core/filter.d.ts
 /**
- * Checks a predicate. If false, the Result becomes Err.
- * Partially equivalent to Rust `filter`.
+ * Prüft eine Bedingung. Wenn falsch, wird das Result zu Err.
+ * Entspricht Rust `filter` (teilweise).
  */
 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
+//#region src/core/match.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.
+ * Löst das Result auf. Das Ende der Pipe.
+ * Entspricht Rust `match`.
  */
-declare function fold<T, E, R$1>(handlers: {
+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: wandelt Err in Ok(defaultValue) um.
+ * Ergebnis ist garantiert Ok → Error-Typ wird `never`.
+ */
+declare function recover<T, E, F>(defaultValue: F): (source: Result<T, E>) => Result<T | F, never>;
 /**
- * @deprecated Use `fold` instead. Will be removed in next major version.
+ * Wie `recover`, aber berechnet den Default-Wert anhand des Errors.
  */
-declare const match: typeof fold;
+declare function recoverWith<T, E, F>(fn: (error: E) => F): (source: Result<T, E>) => Result<T | F, never>;
 //#endregion
-//#region src/operators/tryCatch.d.ts
+//#region src/core/swap.d.ts
 /**
- * Executes a function and catches exceptions.
- * Converts exceptions into Result<E>.
- * Equivalent to Rust `Result::from` for fallible operations.
+ * Tauscht Ok und Err.
+ * Result<T, E> → Result<E, T>
  */
-declare function tryCatch<T, E = unknown>(fn: () => T, errorMapper?: (error: unknown) => E): <SourceT, SourceE>(source: Result<SourceT, SourceE>) => Result<T | SourceT, E | SourceE>;
+declare function swap<T, E>(result: Result<T, E>): Result<E, T>;
 //#endregion
-//#region src/operators/tryMap.d.ts
+//#region src/core/tryCatch.d.ts
 /**
- * Like `map`, but catches exceptions and turns them into Err.
+ * Führt eine Funktion aus und fängt Exceptions ab.
+ * Wandelt Exceptions in Result<E> um.
+ * Entspricht Rust `Result::from` für fallible Operationen.
  */
-declare function tryMap<T, E, U, F = unknown>(project: (value: T) => U, errorMapper?: (error: unknown) => F): (source: Result<T, E>) => Result<U, E | F>;
+declare function tryCatch<T, E = unknown>(fn: () => T, errorMapper?: (error: unknown) => E): (source: Result<any, any>) => Result<T, E>;
 //#endregion
-//#region src/operators/recover.d.ts
+//#region src/core/tryMap.d.ts
 /**
- * Recover: turns Err into Ok(defaultValue).
- * Result is guaranteed Ok → error type becomes `never`.
+ * Wie `map`, aber fängt Exceptions ab und wandelt sie in Err um.
  */
-declare function recover<T, E, D = T>(defaultValue: D): (source: Result<T, E>) => Result<T | D, never>;
+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;
 /**
- * Like `recover`, but computes the default value from the error.
+ * 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 recoverWith<T, E, D = T>(fn: (error: E) => D): (source: Result<T, E>) => Result<T | D, never>;
+declare function collectFirstOk<const Results extends readonly Result<any, any>[]>(results: Results): Result<OkValueOf$2<Results[number]>, ErrValueOf$2<Results[number]>[]>;
 //#endregion
-//#region src/operators-async/mapAsync.d.ts
+//#region src/core/mapAsync.d.ts
 /**
- * Async version of map.
+ * Async-Version von map.
  */
-declare function mapAsync<T, E, U>(project: (value: T) => Promise<U>): (source: Result<T, E>) => Promise<Result<Awaited<U>, E>>;
+declare function mapAsync<T, E, U>(project: (value: T) => Promise<U>): (source: Result<T, E>) => Promise<Result<U, E>>;
 //#endregion
-//#region src/operators-async/mapErrAsync.d.ts
+//#region src/core/mapErrAsync.d.ts
 /**
- * Async version of mapErr.
+ * Async-Version von 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
+//#region src/core/flatMapAsync.d.ts
 /**
- * Async version of flatMap.
- * Allows different error types in the projected Result.
+ * Async-Version von flatMap.
  */
-declare function flatMapAsync<T, E, U, E2 = E>(project: (value: T) => Promise<Result<U, E2>>): (source: Result<T, E>) => Promise<Result<U, E | E2>>;
+declare function flatMapAsync<T, E, U>(project: (value: T) => Promise<Result<U, E>>): (source: Result<T, E>) => Promise<Result<U, E>>;
 //#endregion
-//#region src/operators-async/tapAsync.d.ts
+//#region src/core/tapAsync.d.ts
 /**
- * Async version of tap.
+ * Async-Version von 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>>;
+}): (source: Result<T, E>) => Promise<Result<T, E>>;
 //#endregion
-//#region src/operators-async/filterAsync.d.ts
+//#region src/core/filterAsync.d.ts
 /**
- * Async version of filter.
+ * Async-Version von 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
+//#region src/core/matchAsync.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.
+ * Async-Version von match.
  */
-declare function foldAsync<T, E, R$1>(handlers: {
+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
 /**
- * @deprecated Use `foldAsync` instead. Will be removed in next major version.
+ * Async-Version von tryCatch.
  */
-declare const matchAsync: typeof foldAsync;
+declare function tryCatchAsync<T, E = unknown>(fn: () => Promise<T>, errorMapper?: (error: unknown) => E): (source: Result<any, any>) => Promise<Result<T, E>>;
 //#endregion
-//#region src/operators-async/tryCatchAsync.d.ts
+//#region src/core/tryMapAsync.d.ts
 /**
- * Async version of tryCatch.
+ * Async-Version von tryMap.
  */
-declare function tryCatchAsync<T, E = unknown>(fn: () => Promise<T>, errorMapper?: (error: unknown) => E): <SourceT, SourceE>(source: Result<SourceT, SourceE>) => Promise<Result<T, E | SourceE>>;
+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/operators-async/tryMapAsync.d.ts
+//#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>;
+  /**
+   * Matcht auf den Err-Wert via `.when(...)` Kette.
+   *
+   * Hinweis: aus Type-Safety-Gründen ist `.match()` nur auf einem bereits zu `Err` verengten Result aufrufbar,
+   * z.B. innerhalb von `if (result.isErr()) { ... }`.
+   */
+  match<T, E>(this: Result<T, E>): ErrorMatchBuilder<E, never>;
+  /**
+   * Matcht auf den Err-Wert, aber normalisiert jeden Branch zu einem `Result`:
+   * - Handler dürfen ein `Result` zurückgeben (wird direkt returned)
+   * - oder einen Error-Wert (wird zu `Err(error)` gewrappt)
+   */
+  matchErr<T, E>(this: Result<T, E>): ErrMatchBuilder<T, E, never, never>;
+  /**
+   * Serialisiert das Result in ein einfaches Objekt-Format.
+   * Behält die ursprünglichen Typen bei.
+   */
+  serialize<T, E>(this: Result<T, E>): {
+    isSuccess: boolean;
+    data?: T;
+    error?: E;
+  };
+  /**
+   * Serialisiert das Result in ein user-friendly Format.
+   * Konvertiert Errors zu lesbaren 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
+//#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 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;
 /**
- * Async version of tryMap.
+ * 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 tryMapAsync<T, E, U, F = unknown>(project: (value: T) => Promise<U>, errorMapper?: (error: unknown) => F): (source: Result<T, E>) => Promise<Result<U, E | F>>;
+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 const gen: typeof task;
 //#endregion
-//#region src/unwrap/unwrap.d.ts
+//#region src/core/fold.d.ts
 /**
- * Returns the value or throws an Error.
- * Equivalent to Rust `unwrap`.
+ * 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
+/**
+ * Gibt den Wert zurück oder wirft einen Error.
+ * Entspricht Rust `unwrap`.
  */
 declare function unwrap<T, E>(result: Result<T, E>): T;
 //#endregion
-//#region src/unwrap/unwrapOr.d.ts
+//#region src/core/unwrapOr.d.ts
 /**
- * Returns the value or a default value.
- * Pure function alternative to the instance method.
+ * Gibt den Wert zurück oder einen Default-Wert.
+ * Pure function Alternative zur Instanz-Methode.
  */
-declare function unwrapOr<T, E, D = T>(result: Result<T, E>, defaultValue: D): T | D;
+declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
 //#endregion
-//#region src/unwrap/unwrapOrElse.d.ts
+//#region src/core/unwrapOrElse.d.ts
 /**
- * Returns the value or computes a default value with a function.
- * Equivalent to Rust `unwrap_or_else`.
+ * Gibt den Wert zurück oder berechnet einen Default-Wert mit einer Funktion.
+ * Entspricht Rust `unwrap_or_else`.
  */
-declare function unwrapOrElse<T, E, D = T>(result: Result<T, E>, fn: (error: E) => D): T | D;
+declare function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T;
 //#endregion
-//#region src/unwrap/unwrapOrDefault.d.ts
+//#region src/core/unwrapOrDefault.d.ts
 /**
- * Alias for `unwrapOr`.
- * Equivalent to Rust `unwrap_or_default` (with an explicit default value).
+ * Alias für `unwrapOr`.
+ * Entspricht Rust `unwrap_or_default` (mit explizitem Default-Wert).
  */
-declare function unwrapOrDefault<T, E, D = T>(result: Result<T, E>, defaultValue: D): T | D;
+declare function unwrapOrDefault<T, E>(result: Result<T, E>, defaultValue: T): T;
 //#endregion
-//#region src/unwrap/unwrapOrThrow.d.ts
+//#region src/core/unwrapOrThrow.d.ts
 /**
- * Returns the value or throws the original Err value (not wrapped).
- * Useful to keep `Error` instances with stack traces.
+ * Gibt den Wert zurück oder wirft den originalen Err-Wert (nicht gewrappt).
+ * Nützlich um `Error`-Instanzen inkl. Stacktrace zu erhalten.
  */
 declare function unwrapOrThrow<T, E>(result: Result<T, E>): T;
 //#endregion
-//#region src/unwrap/unwrapErr.d.ts
+//#region src/core/unwrapErr.d.ts
 /**
- * Returns the error or throws an Error.
- * Equivalent to Rust `unwrap_err`.
+ * Gibt den Fehler zurück oder wirft einen Error.
+ * Entspricht Rust `unwrap_err`.
  */
 declare function unwrapErr<T, E>(result: Result<T, E>): E;
 //#endregion
-//#region src/unwrap/expectResult.d.ts
+//#region src/core/expectResult.d.ts
 /**
- * Returns the value or throws an Error with a custom message.
- * Equivalent to Rust `expect`.
+ * Gibt den Wert zurück oder wirft einen Error mit custom Nachricht.
+ * Entspricht Rust `expect`.
  */
 declare function expectResult<T, E>(result: Result<T, E>, message: string): T;
 //#endregion
-//#region src/unwrap/expectErr.d.ts
+//#region src/core/expectErr.d.ts
 /**
- * Returns the error or throws an Error with a custom message.
- * Equivalent to Rust `expect_err`.
+ * Gibt den Fehler zurück oder wirft einen Error mit custom Nachricht.
+ * Entspricht Rust `expect_err`.
  */
 declare function expectErr<T, E>(result: Result<T, E>, message: string): E;
 //#endregion
-//#region src/combinators/and.d.ts
+//#region src/core/and.d.ts
 /**
- * Combines two Results. Returns the second only if the first is Ok.
- * Equivalent to Rust `and`.
+ * Kombiniert zwei Results. Gibt den zweiten zurück nur wenn erster Ok ist.
+ * Entspricht 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
+//#region src/core/or.d.ts
 /**
- * Fallback to another Result when the first is Err.
- * Equivalent to Rust `or`.
+ * Fallback zu einem anderen Result wenn erster Err ist.
+ * Entspricht Rust `or`.
  */
-declare function or<T, E, T2 = T, E2 = E>(result: Result<T, E>, other: Result<T2, E2>): Result<T | T2, E2>;
+declare function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F>;
 //#endregion
-//#region src/combinators/orElse.d.ts
+//#region src/core/orElse.d.ts
 /**
- * Fallback using a function that returns a Result.
- * Equivalent to Rust `or_else`.
+ * Fallback mit einer Funktion die ein Result zurückgibt.
+ * Entspricht 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>;
+declare function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;
 //#endregion
-//#region src/combinators/mapOr.d.ts
+//#region src/core/mapOr.d.ts
 /**
- * Transforms the value or returns a default value.
- * Equivalent to Rust `map_or`.
+ * Transformiert den Wert oder gibt einen Default-Wert zurück.
+ * Entspricht 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
+//#region src/core/mapOrElse.d.ts
 /**
- * Transforms the value or computes a default value with a function.
- * Equivalent to Rust `map_or_else`.
+ * Transformiert den Wert oder berechnet einen Default-Wert mit einer Funktion.
+ * Entspricht 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
+//#region src/core/sequence.d.ts
 /**
- * Combines two Results into a Result of a tuple.
- * Short-circuits on the first Err (left before right).
+ * Kombiniert eine Liste von Results zu einem Result einer Liste.
+ * Short-circuits beim ersten Err.
+ * Analog zu Rust `collect::<Result<Vec<_>, _>>()`.
  */
-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>;
+declare function sequence<T, E>(results: readonly Result<T, E>[]): Result<T[], E>;
 /**
- * Combines two Results and collects errors.
- * - Ok only if both are Ok
- * - Err([errors]) if at least one is Err (left before right)
+ * Alias für `sequence`.
  */
-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>>;
+declare function all<T, E>(results: readonly Result<T, E>[]): Result<T[], E>;
 //#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
+//#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;
 /**
- * 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.
+ * Wie `sequence`, aber für Records/Objekte.
+ * Short-circuits beim ersten Err.
  */
-declare function collectFirstOk<T, E>(results: readonly (Result<T, E> | Result<T, never> | Result<never, E>)[]): Result<T, E[]>;
+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/collections/collectFirstOkAsync.d.ts
+//#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.
+ * Async-Version von 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.
+ * - Nimmt entweder bereits gestartete Promises oder "Thunks" (`() => Awaitable<Result<...>>`).
+ * - Verarbeitet die Inputs strikt sequentiell (wie `for ... of` + `await`).
+ * - Gibt das erste `Ok` zurück und sammelt alle Errors wenn kein `Ok` gefunden wird.
  */
 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
+//#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/race variant of `collectFirstOkAsync`.
+ * Parallel-Variante von `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.
+ * - Startet alle Inputs sofort (Promises oder Thunks).
+ * - Gibt das erste `Ok` zurück, sobald es verfügbar ist.
+ * - Wenn kein `Ok` gefunden wird, gibt ein `Err` mit allen Error-Werten (in Input-Reihenfolge) zurück.
+ * - Rejections werden als `ErrValue` behandelt (`caught as ErrValue`).
+ * - Wenn mehrere Inputs ein `Ok` liefern, gewinnt das zuerst abgeschlossene Ergebnis.
+ *   Bei gleichzeitiger Completion gewinnt das zuerst beobachtete Ergebnis.
+ * - Wenn kein `Ok` kommt und mindestens ein Input nie settled, bleibt das Promise offen.
  */
-declare function collectFirstOkRaceAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(inputs: Inputs): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>>;
+declare function collectFirstOkParallelAsync<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;
+//#region src/core/collectAllErrors.d.ts
 /**
- * Combines a list of Results.
- * Returns Ok(values) only if all are Ok, otherwise Err([errors]).
+ * Kombiniert eine Liste von Results.
+ * Gibt Ok(values) nur zurück wenn alle Ok sind, sonst 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]>>>;
+declare function collectAllErrors<T, E>(results: readonly Result<T, E>[]): Result<T[], E[]>;
 //#endregion
-//#region src/collections/partition.d.ts
+//#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.
+ * Partitioniert Results in Ok-Werte und Err-Fehler.
  */
 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
+//#region src/core/flatten.d.ts
 /**
  * Flacht ein nested Result ab.
  * Result<Result<T, E>, E> → Result<T, E>
@@ -898,136 +563,54 @@ declare function partition<const Results extends readonly Result<any, any>[]>(re
  */
 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
+//#region src/core/toPromise.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
- * ```
+ * Konvertiert ein Result zu einem Promise.
+ * Ok → resolve(value), Err → reject(error)
  */
 declare function toPromise<T, E>(result: Result<T, E>): Promise<T>;
 //#endregion
-//#region src/conversions/toNullable.d.ts
+//#region src/core/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
- * ```
+ * Konvertiert ein Result zu `T | null`.
+ * Ok → value, Err → null
  */
 declare function toNullable<T, E>(result: Result<T, E>): T | null;
 //#endregion
-//#region src/utils/isOk.d.ts
+//#region src/core/isOk.d.ts
 /**
- * Checks whether a Result is Ok.
- * Pure function alternative to the instance method.
+ * Prüft ob ein Result Ok ist.
+ * Pure function Alternative zur Instanz-Methode.
  */
-declare function isOk<T, E>(result: Result<T, E>): result is Result<T, E> & {
-  readonly value: T;
-  readonly error: undefined;
-};
+declare function isOk<T, E>(result: Result<T, E>): result is Ok<T, E>;
 //#endregion
-//#region src/utils/isErr.d.ts
+//#region src/core/isErr.d.ts
 /**
- * Checks whether a Result is Err.
- * Pure function alternative to the instance method.
+ * Prüft ob ein Result Err ist.
+ * Pure function Alternative zur Instanz-Methode.
  */
-declare function isErr<T, E>(result: Result<T, E>): result is Result<T, E> & {
-  readonly value: undefined;
-  readonly error: E;
-};
+declare function isErr<T, E>(result: Result<T, E>): result is Err<T, E>;
 //#endregion
-//#region src/utils/contains.d.ts
+//#region src/core/contains.d.ts
 /**
- * Checks whether the Result contains a specific value.
- * Equivalent to Rust `contains`.
+ * Prüft ob das Result einen bestimmten Wert enthält.
+ * Entspricht Rust `contains`.
  */
-declare function contains<T, E>(result: Result<any, E>, value: T): boolean;
+declare function contains<T, E>(result: Result<T, E>, value: T): boolean;
 //#endregion
-//#region src/utils/containsErr.d.ts
+//#region src/core/containsErr.d.ts
 /**
- * Checks whether the Result contains a specific error.
- * Analogous to `contains` for the Err case.
+ * Prüft ob das Result einen bestimmten Fehler enthält.
+ * Analog zu `contains` für den Err-Fall.
  */
 declare function containsErr<T, E>(result: Result<T, E>, error: E): boolean;
 //#endregion
-//#region src/utils/isResult.d.ts
+//#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, 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 };
+export { AsyncOperatorFunction, type Awaitable, Err, Ok, OperatorFunction, Result, ResultType, 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 };
 //# sourceMappingURL=index.d.mts.map