@shirudo/result 0.0.4 → 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;
@@ -444,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
@@ -549,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
@@ -560,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
@@ -574,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
@@ -597,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