@onrails/result/dist/compat/neverthrow.d.cts

Tagged Result / ResultAsync for railway-oriented TypeScript — pure tagged unions, neverthrow-shaped compat shim, FL-friendly

import { R as ResultAsync, a as InferOk, I as InferErr } from '../async-DcXR7k9K.cjs';
import { R as Result$1 } from '../types-BQ9vv0nD.cjs';

/** @deprecated Migration shim — prefer `@onrails/result` and `@onrails/result/fluent`. */

type TupleOk<R extends readonly CompatResult<unknown, unknown>[]> = {
    [K in keyof R]: R[K] extends CompatResult<infer T, unknown> ? T : never;
};
type TupleErr<R extends readonly CompatResult<unknown, unknown>[]> = {
    [K in keyof R]: R[K] extends CompatResult<unknown, infer F> ? F : never;
}[number];
type AsyncTupleOk<R extends readonly CompatResultAsync<unknown, unknown>[]> = {
    [K in keyof R]: R[K] extends CompatResultAsync<infer T, unknown> ? T : never;
};
type AsyncTupleErr<R extends readonly CompatResultAsync<unknown, unknown>[]> = {
    [K in keyof R]: R[K] extends CompatResultAsync<unknown, infer F> ? F : never;
}[number];
declare class CompatResult<T, E> {
    readonly inner: Result$1<T, E>;
    constructor(inner: Result$1<T, E>);
    static fromThrowable<A extends readonly unknown[], U, F>(fn: (...args: A) => U, onThrow: (error: unknown) => F): (...args: A) => CompatResult<U, F>;
    static combine<const R extends readonly CompatResult<unknown, unknown>[]>(results: R): CompatResult<TupleOk<R>, TupleErr<R>>;
    get value(): T;
    get error(): E;
    isOk(): boolean;
    isErr(): boolean;
    map<U>(fn: (value: T) => U): CompatResult<U, E>;
    mapErr<F>(fn: (error: E) => F): CompatResult<T, F>;
    andThen<U, F = E>(fn: (value: T) => CompatResult<U, F>): CompatResult<U, E | F>;
    asyncAndThen<U, F = E>(fn: (value: T) => CompatResultAsync<U, F> | ResultAsync<U, F>): CompatResultAsync<U, E | F>;
    orElse<F>(fn: (error: E) => CompatResult<T, F>): CompatResult<T, F>;
    match<U1, U2 = U1>(onOk: (value: T) => U1, onErr: (error: E) => U2): U1 | U2;
    unwrapOr<U>(defaultValue: U): T | U;
    _unsafeUnwrap(): T;
    _unsafeUnwrapErr(): E;
}
declare const Result: typeof CompatResult;
type Result<T, E> = CompatResult<T, E>;
declare const ok: <T, E = never>(value: T) => CompatResult<T, E>;
declare const err: <T = never, E = unknown>(error: E) => CompatResult<T, E>;
/** `await` yields `CompatResult` so `.isOk()` / `.value` / `.match()` work without `.resolve()`. */
declare class CompatResultAsync<T, E> implements PromiseLike<CompatResult<T, E>> {
    private readonly inner;
    private constructor();
    static fromInner<T, E>(inner: ResultAsync<T, E>): CompatResultAsync<T, E>;
    toCore(): ResultAsync<T, E>;
    static ok<T, E = never>(value: T): CompatResultAsync<T, E>;
    static err<T = never, E = unknown>(error: E): CompatResultAsync<T, E>;
    static fromPromise<T, E>(promise: PromiseLike<T>, onReject: (error: unknown) => E): CompatResultAsync<T, E>;
    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): CompatResultAsync<T, E>;
    static fromThrowable<A extends readonly unknown[], U, F>(fn: (...args: A) => Promise<U>, onThrow: (error: unknown) => F): (...args: A) => CompatResultAsync<U, F>;
    static combine<const R extends readonly CompatResultAsync<unknown, unknown>[]>(results: R): CompatResultAsync<AsyncTupleOk<R>, AsyncTupleErr<R>>;
    then<R1 = CompatResult<T, E>, R2 = never>(onfulfilled?: ((value: CompatResult<T, E>) => R1 | PromiseLike<R1>) | undefined | null, onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | undefined | null): Promise<R1 | R2>;
    resolve(): Promise<Result$1<T, E>>;
    map<U>(fn: (value: T) => U): CompatResultAsync<U, E>;
    mapErr<F>(fn: (error: E) => F): CompatResultAsync<T, F>;
    andThen<R extends AnyAsyncOrSyncResult>(fn: (value: T) => R): CompatResultAsync<UnwrapOk<R>, E | UnwrapErr<R>>;
    chain<R extends AnyAsyncOrSyncResult>(fn: (value: T) => R): CompatResultAsync<UnwrapOk<R>, E | UnwrapErr<R>>;
    flatMap<R extends AnyAsyncOrSyncResult>(fn: (value: T) => R): CompatResultAsync<UnwrapOk<R>, E | UnwrapErr<R>>;
    orElse<R extends AnyAsyncOrSyncResult>(fn: (error: E) => R): CompatResultAsync<T | UnwrapOk<R>, UnwrapErr<R>>;
    unwrapOr<U>(defaultValue: U): Promise<T | U>;
    isOk(): Promise<boolean>;
    isErr(): Promise<boolean>;
    match<U1, U2 = U1>(onOk: (value: T) => U1, onErr: (error: E) => U2): Promise<U1 | U2>;
    andTee(fn: (value: T) => void | Promise<void>): CompatResultAsync<T, E>;
    orTee(fn: (error: E) => void | Promise<void>): CompatResultAsync<T, E>;
}
type AnyAsyncOrSyncResult = CompatResultAsync<unknown, unknown> | ResultAsync<unknown, unknown> | CompatResult<unknown, unknown> | Result$1<unknown, unknown>;
type UnwrapOk<R> = R extends CompatResultAsync<infer U, unknown> ? U : R extends CompatResult<infer U, unknown> ? U : InferOk<R>;
type UnwrapErr<R> = R extends CompatResultAsync<unknown, infer F> ? F : R extends CompatResult<unknown, infer F> ? F : InferErr<R>;

declare const okAsync: typeof CompatResultAsync.ok;
declare const errAsync: typeof CompatResultAsync.err;
declare const fromPromise: typeof CompatResultAsync.fromPromise;
declare const fromSafePromise: typeof CompatResultAsync.fromSafePromise;

export { CompatResult, CompatResultAsync, Result, CompatResultAsync as ResultAsync, err, errAsync, fromPromise, fromSafePromise, ok, okAsync };