@shirudo/result 0.0.3 → 0.0.5

package/dist/index.d.mts

@@ -50,11 +50,11 @@ declare abstract class Pipeable {
 type Ctor<T> = abstract new (...args: any[]) => T;
 type TypeGuard<E, A extends E> = (error: E) => error is A;
 /**
- * Matcher für Err-Values (liefert einen beliebigen Return-Type, z.B. string messages).
+ * Matcher for Err values (returns an arbitrary return type, e.g. string messages).
  *
- * - `.when(Ctor, handler)` matched via `instanceof`
- * - `.whenGuard(guard, handler)` matched via Type-Guard
- * - `.run()` ist nur erlaubt, wenn alle Error-Cases behandelt wurden (`E` wurde zu `never` reduziert)
+ * - `.when(Ctor, handler)` matches via `instanceof`
+ * - `.whenGuard(guard, handler)` matches via Type-Guard
+ * - `.run()` is only allowed if all error cases have been handled (`E` has been reduced to `never`)
  */
 declare class ErrorMatchBuilder<E, R$1> {
   #private;
@@ -68,11 +68,11 @@ 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 für `Result`-Errors, der immer wieder ein `Result` zurückgibt.
+ * Matcher for `Result` Errors, which returns a `Result` again.
  *
- * Handler dürfen:
- * - ein `Result` zurückgeben (wird direkt returned)
- * - einen Error-Wert zurückgeben (wird automatisch zu `Err(error)` gewrappt)
+ * Handlers may:
+ * - return a `Result` (is returned directly)
+ * - return an Error value (is automatically wrapped into `Err(error)`)
  */
 declare class ErrMatchBuilder<T, E, OutT, OutE> {
   #private;
@@ -86,55 +86,55 @@ declare class ErrMatchBuilder<T, E, OutT, OutE> {
 //#endregion
 //#region src/core/map.d.ts
 /**
- * Transformiert den Wert (Ok-Fall).
- * Entspricht Rust `map`.
+ * Transforms the value (Ok case).
+ * Corresponds to Rust `map`.
  */
 declare function map<T, E, U>(project: (value: T) => U): (source: Result<T, E>) => Result<U, E>;
 //#endregion
 //#region src/core/mapErr.d.ts
 /**
- * Transformiert den Fehler (Err-Fall).
- * Entspricht Rust `map_err`.
+ * Transforms the error (Err case).
+ * Corresponds to Rust `map_err`.
  */
 declare function mapErr<T, E, F>(project: (error: E) => F): (source: Result<T, E>) => Result<T, F>;
 //#endregion
 //#region src/core/mapBoth.d.ts
 /**
- * Transformiert sowohl den Ok-Wert als auch den Err-Fehler.
- * Entspricht FP `bimap` / `mapBoth`.
+ * Transforms both the Ok value and the Err error.
+ * Corresponds to FP `bimap` / `mapBoth`.
  */
 declare function mapBoth<T, E, U, F>(mapOk: (value: T) => U, mapErr: (error: E) => F): (source: Result<T, E>) => Result<U, F>;
 /**
- * Alias für `mapBoth`.
+ * Alias for `mapBoth`.
  */
 declare const bimap: typeof mapBoth;
 //#endregion
 //#region src/core/flatMap.d.ts
 /**
- * Verkettet eine weitere Operation, die ein Result zurückgibt.
- * Entspricht Rust `and_then` oder JS `flatMap`.
+ * Chains another operation that returns a Result.
+ * Corresponds to Rust `and_then` or JS `flatMap`.
  */
 declare function flatMap<T, E, U>(project: (value: T) => Result<U, E>): (source: Result<T, E>) => Result<U, E>;
 //#endregion
 //#region src/core/zip.d.ts
 /**
- * Kombiniert zwei Results zu einem Result eines Tupels.
- * Short-circuits beim ersten Err (links vor rechts).
+ * 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>;
 /**
- * Kombiniert zwei Results und sammelt Fehler ein.
- * - Ok nur wenn beide Ok sind
- * - Err([errors]) wenn mindestens ein Err ist (links vor rechts)
+ * Combines two Results and collects errors.
+ * - Ok only if both are Ok
+ * - Err([errors]) if at least one is Err (left before right)
  */
 declare function combine<A, AE, B, BE>(left: Result<A, AE>, right: Result<B, BE>): Result<[A, B], Array<AE | BE>>;
 declare function combine<A, AE, B, BE>(right: Result<B, BE>): (left: Result<A, AE>) => Result<[A, B], Array<AE | BE>>;
 //#endregion
 //#region src/core/tap.d.ts
 /**
- * Führt einen Seiteneffekt aus (Logging, Debugging), ohne das Result zu ändern.
- * Entspricht Rust `inspect` / `inspect_err`.
+ * Executes a side effect (logging, debugging) without changing the Result.
+ * Corresponds to Rust `inspect` / `inspect_err`.
  */
 declare function tap<T, E>(observer: {
   ok?: (val: T) => void;
@@ -143,15 +143,15 @@ declare function tap<T, E>(observer: {
 //#endregion
 //#region src/core/filter.d.ts
 /**
- * Prüft eine Bedingung. Wenn falsch, wird das Result zu Err.
- * Entspricht Rust `filter` (teilweise).
+ * Checks a condition. If false, the Result becomes Err.
+ * Corresponds to Rust `filter` (partially).
  */
 declare function filter<T, E>(predicate: (val: T) => boolean, errorFn: () => E): (source: Result<T, E>) => Result<T, E>;
 //#endregion
 //#region src/core/match.d.ts
 /**
- * Löst das Result auf. Das Ende der Pipe.
- * Entspricht Rust `match`.
+ * Resolves the Result. The end of the pipe.
+ * Corresponds to Rust `match`.
  */
 declare function match<T, E, R$1>(handlers: {
   ok: (val: T) => R$1;
@@ -160,33 +160,33 @@ declare function match<T, E, R$1>(handlers: {
 //#endregion
 //#region src/core/recover.d.ts
 /**
- * Recover: wandelt Err in Ok(defaultValue) um.
- * Ergebnis ist garantiert Ok → Error-Typ wird `never`.
+ * Recover: converts Err to Ok(defaultValue).
+ * Result is guaranteed to be Ok → Error type becomes `never`.
  */
 declare function recover<T, E, F>(defaultValue: F): (source: Result<T, E>) => Result<T | F, never>;
 /**
- * Wie `recover`, aber berechnet den Default-Wert anhand des Errors.
+ * Like `recover`, but calculates the default value based on the error.
  */
 declare function recoverWith<T, E, F>(fn: (error: E) => F): (source: Result<T, E>) => Result<T | F, never>;
 //#endregion
 //#region src/core/swap.d.ts
 /**
- * Tauscht Ok und Err.
+ * Swaps Ok and Err.
  * Result<T, E> → Result<E, T>
  */
 declare function swap<T, E>(result: Result<T, E>): Result<E, T>;
 //#endregion
 //#region src/core/tryCatch.d.ts
 /**
- * Führt eine Funktion aus und fängt Exceptions ab.
- * Wandelt Exceptions in Result<E> um.
- * Entspricht Rust `Result::from` für fallible Operationen.
+ * Executes a function and catches exceptions.
+ * Converts exceptions into Result<E>.
+ * Corresponds to Rust `Result::from` for fallible operations.
  */
 declare function tryCatch<T, E = unknown>(fn: () => T, errorMapper?: (error: unknown) => E): (source: Result<any, any>) => Result<T, E>;
 //#endregion
 //#region src/core/tryMap.d.ts
 /**
- * Wie `map`, aber fängt Exceptions ab und wandelt sie in Err um.
+ * Like `map`, but catches exceptions and converts them to Err.
  */
 declare function tryMap<T, E, U, F = unknown>(project: (value: T) => U, errorMapper?: (error: unknown) => F): (source: Result<T, E>) => Result<U, E | F>;
 //#endregion
@@ -202,25 +202,25 @@ declare function collectFirstOk<const Results extends readonly Result<any, any>[
 //#endregion
 //#region src/core/mapAsync.d.ts
 /**
- * Async-Version von map.
+ * Async version of map.
  */
 declare function mapAsync<T, E, U>(project: (value: T) => Promise<U>): (source: Result<T, E>) => Promise<Result<U, E>>;
 //#endregion
 //#region src/core/mapErrAsync.d.ts
 /**
- * Async-Version von mapErr.
+ * Async version of mapErr.
  */
 declare function mapErrAsync<T, E, F>(project: (error: E) => Promise<F>): (source: Result<T, E>) => Promise<Result<T, F>>;
 //#endregion
 //#region src/core/flatMapAsync.d.ts
 /**
- * Async-Version von flatMap.
+ * Async version of flatMap.
  */
 declare function flatMapAsync<T, E, U>(project: (value: T) => Promise<Result<U, E>>): (source: Result<T, E>) => Promise<Result<U, E>>;
 //#endregion
 //#region src/core/tapAsync.d.ts
 /**
- * Async-Version von tap.
+ * Async version of tap.
  */
 declare function tapAsync<T, E>(observer: {
   ok?: (val: T) => Promise<void>;
@@ -229,13 +229,13 @@ declare function tapAsync<T, E>(observer: {
 //#endregion
 //#region src/core/filterAsync.d.ts
 /**
- * Async-Version von filter.
+ * Async version of filter.
  */
 declare function filterAsync<T, E>(predicate: (val: T) => Promise<boolean>, errorFn: () => Promise<E>): (source: Result<T, E>) => Promise<Result<T, E>>;
 //#endregion
 //#region src/core/matchAsync.d.ts
 /**
- * Async-Version von match.
+ * Async version of match.
  */
 declare function matchAsync<T, E, R$1>(handlers: {
   ok: (val: T) => Promise<R$1>;
@@ -244,13 +244,13 @@ declare function matchAsync<T, E, R$1>(handlers: {
 //#endregion
 //#region src/core/tryCatchAsync.d.ts
 /**
- * Async-Version von tryCatch.
+ * Async version of tryCatch.
  */
 declare function tryCatchAsync<T, E = unknown>(fn: () => Promise<T>, errorMapper?: (error: unknown) => E): (source: Result<any, any>) => Promise<Result<T, E>>;
 //#endregion
 //#region src/core/tryMapAsync.d.ts
 /**
- * Async-Version von tryMap.
+ * 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
@@ -289,21 +289,21 @@ declare abstract class ResultBase extends Pipeable {
    */
   [Symbol.iterator](): Generator<unknown, OkValue<this>, unknown>;
   /**
-   * Matcht auf den Err-Wert via `.when(...)` Kette.
+   * Matches on the Err value via `.when(...)` chain.
    *
-   * Hinweis: aus Type-Safety-Gründen ist `.match()` nur auf einem bereits zu `Err` verengten Result aufrufbar,
-   * z.B. innerhalb von `if (result.isErr()) { ... }`.
+   * Note: for type safety reasons, `.match()` can only be called on a Result already narrowed to `Err`,
+   * e.g. inside `if (result.isErr()) { ... }`.
    */
   match<T, E>(this: Result<T, E>): ErrorMatchBuilder<E, never>;
   /**
-   * 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)
+   * Matches on the Err value, but normalizes every branch to a `Result`:
+   * - Handlers may return a `Result` (is returned directly)
+   * - or an Error value (is wrapped into `Err(error)`)
    */
   matchErr<T, E>(this: Result<T, E>): ErrMatchBuilder<T, E, never, never>;
   /**
-   * Serialisiert das Result in ein einfaches Objekt-Format.
-   * Behält die ursprünglichen Typen bei.
+   * Serializes the Result into a simple object format.
+   * Preserves the original types.
    */
   serialize<T, E>(this: Result<T, E>): {
     isSuccess: boolean;
@@ -311,8 +311,8 @@ declare abstract class ResultBase extends Pipeable {
     error?: E;
   };
   /**
-   * Serialisiert das Result in ein user-friendly Format.
-   * Konvertiert Errors zu lesbaren Strings.
+   * Serializes the Result into a user-friendly format.
+   * Converts Errors to readable strings.
    */
   toUserFriendly<T, E>(this: Result<T, E>): {
     isSuccess: boolean;
@@ -372,6 +372,52 @@ declare function task<const Y, const R$1>(makeGenerator: () => AnyGenerator<Y, R
 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/errors.d.ts
+declare const ERR_INVALID_STATE: "ERR_INVALID_STATE";
+declare const ERR_TASK_YIELD_NOT_RESULT: "ERR_TASK_YIELD_NOT_RESULT";
+declare const ERR_MATCH_ON_OK: "ERR_MATCH_ON_OK";
+declare const ERR_UNWRAP_ON_ERR: "ERR_UNWRAP_ON_ERR";
+declare const ERR_UNWRAP_ERR_ON_OK: "ERR_UNWRAP_ERR_ON_OK";
+declare const ERR_EXPECT_OK: "ERR_EXPECT_OK";
+declare const ERR_EXPECT_ERR: "ERR_EXPECT_ERR";
+type ResultErrorCode = typeof ERR_INVALID_STATE | typeof ERR_TASK_YIELD_NOT_RESULT | typeof ERR_MATCH_ON_OK | typeof ERR_UNWRAP_ON_ERR | typeof ERR_UNWRAP_ERR_ON_OK | typeof ERR_EXPECT_OK | typeof ERR_EXPECT_ERR;
+declare class ResultError extends Error {
+  readonly code: ResultErrorCode;
+  readonly context?: string;
+  constructor(message: string, code: ResultErrorCode, context?: string);
+}
+declare class ResultTypeError extends TypeError {
+  readonly code: ResultErrorCode;
+  readonly context?: string;
+  constructor(message: string, code: ResultErrorCode, context?: string);
+}
+declare class InvalidResultStateError extends ResultError {
+  constructor(context?: string);
+}
+declare class TaskYieldNotResultError extends ResultTypeError {
+  readonly yieldedValue: unknown;
+  constructor(yieldedValue: unknown);
+}
+declare class MatchOnOkError extends ResultTypeError {
+  constructor();
+}
+declare class UnwrapOnErrError extends ResultTypeError {
+  readonly errorValue: unknown;
+  constructor(errorValue: unknown);
+}
+declare class UnwrapErrOnOkError extends ResultTypeError {
+  readonly okValue: unknown;
+  constructor(okValue: unknown);
+}
+declare class ExpectOkError extends ResultError {
+  readonly expectedMessage: string;
+  constructor(expectedMessage: string);
+}
+declare class ExpectErrError extends ResultError {
+  readonly expectedMessage: string;
+  constructor(expectedMessage: string);
+}
+//#endregion
 //#region src/core/fold.d.ts
 /**
  * Folds the Result into a single value by applying one of two functions.
@@ -398,104 +444,104 @@ declare function foldAsync<T, E, R$1>(handlers: {
 //#endregion
 //#region src/core/unwrap.d.ts
 /**
- * Gibt den Wert zurück oder wirft einen Error.
- * Entspricht Rust `unwrap`.
+ * Returns the value or throws an Error.
+ * Corresponds to Rust `unwrap`.
  */
 declare function unwrap<T, E>(result: Result<T, E>): T;
 //#endregion
 //#region src/core/unwrapOr.d.ts
 /**
- * Gibt den Wert zurück oder einen Default-Wert.
- * Pure function Alternative zur Instanz-Methode.
+ * Returns the value or a default value.
+ * Pure function alternative to the instance method.
  */
 declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
 //#endregion
 //#region src/core/unwrapOrElse.d.ts
 /**
- * Gibt den Wert zurück oder berechnet einen Default-Wert mit einer Funktion.
- * Entspricht Rust `unwrap_or_else`.
+ * Returns the value or calculates a default value using a function.
+ * Corresponds to Rust `unwrap_or_else`.
  */
 declare function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T;
 //#endregion
 //#region src/core/unwrapOrDefault.d.ts
 /**
- * Alias für `unwrapOr`.
- * Entspricht Rust `unwrap_or_default` (mit explizitem Default-Wert).
+ * Alias for `unwrapOr`.
+ * Corresponds to Rust `unwrap_or_default` (with explicit default value).
  */
 declare function unwrapOrDefault<T, E>(result: Result<T, E>, defaultValue: T): T;
 //#endregion
 //#region src/core/unwrapOrThrow.d.ts
 /**
- * Gibt den Wert zurück oder wirft den originalen Err-Wert (nicht gewrappt).
- * Nützlich um `Error`-Instanzen inkl. Stacktrace zu erhalten.
+ * Returns the value or throws the original Err value (not wrapped).
+ * Useful to preserve `Error` instances including stack traces.
  */
 declare function unwrapOrThrow<T, E>(result: Result<T, E>): T;
 //#endregion
 //#region src/core/unwrapErr.d.ts
 /**
- * Gibt den Fehler zurück oder wirft einen Error.
- * Entspricht Rust `unwrap_err`.
+ * Returns the error or throws an Error.
+ * Corresponds to Rust `unwrap_err`.
  */
 declare function unwrapErr<T, E>(result: Result<T, E>): E;
 //#endregion
 //#region src/core/expectResult.d.ts
 /**
- * Gibt den Wert zurück oder wirft einen Error mit custom Nachricht.
- * Entspricht Rust `expect`.
+ * Returns the value or throws an Error with a custom message.
+ * Corresponds to Rust `expect`.
  */
 declare function expectResult<T, E>(result: Result<T, E>, message: string): T;
 //#endregion
 //#region src/core/expectErr.d.ts
 /**
- * Gibt den Fehler zurück oder wirft einen Error mit custom Nachricht.
- * Entspricht Rust `expect_err`.
+ * Returns the error or throws an Error with a custom message.
+ * Corresponds to Rust `expect_err`.
  */
 declare function expectErr<T, E>(result: Result<T, E>, message: string): E;
 //#endregion
 //#region src/core/and.d.ts
 /**
- * Kombiniert zwei Results. Gibt den zweiten zurück nur wenn erster Ok ist.
- * Entspricht Rust `and`.
+ * Combines two Results. Returns the second one only if the first is Ok.
+ * Corresponds to Rust `and`.
  */
 declare function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E>;
 //#endregion
 //#region src/core/or.d.ts
 /**
- * Fallback zu einem anderen Result wenn erster Err ist.
- * Entspricht Rust `or`.
+ * Fallback to another Result if the first is Err.
+ * Corresponds to Rust `or`.
  */
 declare function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F>;
 //#endregion
 //#region src/core/orElse.d.ts
 /**
- * Fallback mit einer Funktion die ein Result zurückgibt.
- * Entspricht Rust `or_else`.
+ * Fallback with a function that returns a Result.
+ * Corresponds to Rust `or_else`.
  */
 declare function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;
 //#endregion
 //#region src/core/mapOr.d.ts
 /**
- * Transformiert den Wert oder gibt einen Default-Wert zurück.
- * Entspricht Rust `map_or`.
+ * Transforms the value or returns a default value.
+ * Corresponds to Rust `map_or`.
  */
 declare function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U;
 //#endregion
 //#region src/core/mapOrElse.d.ts
 /**
- * Transformiert den Wert oder berechnet einen Default-Wert mit einer Funktion.
- * Entspricht Rust `map_or_else`.
+ * Transforms the value or calculates a default value using a function.
+ * Corresponds to Rust `map_or_else`.
  */
 declare function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U;
 //#endregion
 //#region src/core/sequence.d.ts
 /**
- * Kombiniert eine Liste von Results zu einem Result einer Liste.
- * Short-circuits beim ersten Err.
- * Analog zu Rust `collect::<Result<Vec<_>, _>>()`.
+ * Combines a list of Results into a single Result of a list.
+ * Short-circuits on the first Err.
+ * Analogous to Rust `collect::<Result<Vec<_>, _>>()`.
  */
 declare function sequence<T, E>(results: readonly Result<T, E>[]): Result<T[], E>;
 /**
- * Alias für `sequence`.
+ * Alias for `sequence`.
  */
 declare function all<T, E>(results: readonly Result<T, E>[]): Result<T[], E>;
 //#endregion
@@ -503,8 +549,8 @@ declare function all<T, E>(results: readonly Result<T, E>[]): Result<T[], E>;
 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;
 /**
- * Wie `sequence`, aber für Records/Objekte.
- * Short-circuits beim ersten Err.
+ * Like `sequence`, but for Records/Objects.
+ * Short-circuits on the first Err.
  */
 declare function sequenceRecord<const R$1 extends Record<string, Result<any, any>>>(record: R$1): Result<{ [K in keyof R$1]: OkValueOf$1<R$1[K]> }, ErrValueOf$1<R$1[keyof R$1]>>;
 //#endregion
@@ -514,11 +560,11 @@ type ResolvedResult$1<I> = I extends (() => infer R) ? Awaited<R> : I extends Pr
 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 von collectFirstOk.
+ * Async version of collectFirstOk.
  *
- * - 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.
+ * - Takes either already started Promises or "Thunks" (`() => Awaitable<Result<...>>`).
+ * - Processes inputs strictly sequentially (like `for ... of` + `await`).
+ * - Returns the first `Ok` and collects all errors if no `Ok` is found.
  */
 declare function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput$1[]>(inputs: Inputs): Promise<Result<OkValueOfInput$1<Inputs[number]>, ErrValueOfInput$1<Inputs[number]>[]>>;
 //#endregion
@@ -528,22 +574,22 @@ type ResolvedResult<I> = I extends (() => infer R) ? Awaited<R> : I extends Prom
 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-Variante von `collectFirstOkAsync`.
+ * Parallel version of `collectFirstOkAsync`.
  *
- * - 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.
+ * - Starts all inputs immediately (Promises or Thunks).
+ * - Returns the first `Ok` as soon as it is available.
+ * - If no `Ok` is found, returns an `Err` with all error values (in input order).
+ * - Rejections are treated as `ErrValue` (`caught as ErrValue`).
+ * - If multiple inputs provide an `Ok`, the one that completes first wins.
+ *   In case of simultaneous completion, the first observed result wins.
+ * - If no `Ok` arrives and at least one input never settles, the Promise remains pending.
  */
 declare function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(inputs: Inputs): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>>;
 //#endregion
 //#region src/core/collectAllErrors.d.ts
 /**
- * Kombiniert eine Liste von Results.
- * Gibt Ok(values) nur zurück wenn alle Ok sind, sonst Err([errors]).
+ * Combines a list of Results.
+ * Return Ok(values) only if all are Ok, otherwise Err([errors]).
  */
 declare function collectAllErrors<T, E>(results: readonly Result<T, E>[]): Result<T[], E[]>;
 //#endregion
@@ -551,57 +597,57 @@ declare function collectAllErrors<T, E>(results: readonly Result<T, E>[]): Resul
 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;
 /**
- * Partitioniert Results in Ok-Werte und Err-Fehler.
+ * Partitions Results into Ok values and Err errors.
  */
 declare function partition<const Results extends readonly Result<any, any>[]>(results: Results): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>];
 //#endregion
 //#region src/core/flatten.d.ts
 /**
- * Flacht ein nested Result ab.
+ * Flattens a nested Result.
  * Result<Result<T, E>, E> → Result<T, E>
- * Entspricht Rust `flatten`.
+ * Corresponds to Rust `flatten`.
  */
 declare function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E>;
 //#endregion
 //#region src/core/toPromise.d.ts
 /**
- * Konvertiert ein Result zu einem Promise.
+ * Converts a Result to a Promise.
  * Ok → resolve(value), Err → reject(error)
  */
 declare function toPromise<T, E>(result: Result<T, E>): Promise<T>;
 //#endregion
 //#region src/core/toNullable.d.ts
 /**
- * Konvertiert ein Result zu `T | null`.
+ * Converts a Result to `T | null`.
  * Ok → value, Err → null
  */
 declare function toNullable<T, E>(result: Result<T, E>): T | null;
 //#endregion
 //#region src/core/isOk.d.ts
 /**
- * Prüft ob ein Result Ok ist.
- * Pure function Alternative zur Instanz-Methode.
+ * Checks if a Result is Ok.
+ * Pure function alternative to the instance method.
  */
 declare function isOk<T, E>(result: Result<T, E>): result is Ok<T, E>;
 //#endregion
 //#region src/core/isErr.d.ts
 /**
- * Prüft ob ein Result Err ist.
- * Pure function Alternative zur Instanz-Methode.
+ * Checks if a Result is Err.
+ * Pure function alternative to the instance method.
  */
 declare function isErr<T, E>(result: Result<T, E>): result is Err<T, E>;
 //#endregion
 //#region src/core/contains.d.ts
 /**
- * Prüft ob das Result einen bestimmten Wert enthält.
- * Entspricht Rust `contains`.
+ * Checks if the Result contains a specific value.
+ * Corresponds to Rust `contains`.
  */
 declare function contains<T, E>(result: Result<T, E>, value: T): boolean;
 //#endregion
 //#region src/core/containsErr.d.ts
 /**
- * Prüft ob das Result einen bestimmten Fehler enthält.
- * Analog zu `contains` für den Err-Fall.
+ * Checks if 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
@@ -612,5 +658,5 @@ declare function containsErr<T, E>(result: Result<T, E>, error: E): boolean;
  */
 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, collectFirstOkParallelAsync, combine, contains, containsErr, err, expectErr, expectResult, filter, filterAsync, flatMap, flatMapAsync, flatten, fold, foldAsync, fromNullable, fromPromise, gen, isErr, isOk, isResult, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, ok, okIf, okIfLazy, or, orElse, partition, recover, recoverWith, sequence, sequenceRecord, swap, tap, tapAsync, task, toNullable, toPromise, tryCatch, tryCatchAsync, tryFn, tryMap, tryMapAsync, unwrap, unwrapErr, unwrapOr, unwrapOrDefault, unwrapOrElse, unwrapOrThrow, zip };
+export { AsyncOperatorFunction, type Awaitable, ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_STATE, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, Err, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchOnOkError, Ok, OperatorFunction, Result, ResultError, ResultErrorCode, ResultType, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError, all, and, bimap, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, combine, contains, containsErr, err, expectErr, expectResult, filter, filterAsync, flatMap, flatMapAsync, flatten, fold, foldAsync, fromNullable, fromPromise, gen, isErr, isOk, isResult, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, ok, okIf, okIfLazy, or, orElse, partition, recover, recoverWith, sequence, sequenceRecord, swap, tap, tapAsync, task, toNullable, toPromise, tryCatch, tryCatchAsync, tryFn, tryMap, tryMapAsync, unwrap, unwrapErr, unwrapOr, unwrapOrDefault, unwrapOrElse, unwrapOrThrow, zip };
 //# sourceMappingURL=index.d.mts.map