import { Nullish } from "../types/index.js";
import { SafeParseReturnType, ZodError, ZodType, input, output } from "zod/v3";

//#region lib/util/result.d.ts
type Val = NonNullable<unknown>;
interface Ok<T extends Val> {
  readonly ok: true;
  readonly val: T;
  readonly err?: never;
}
interface Err<E extends Val> {
  readonly ok: false;
  readonly err: E;
  readonly val?: never;
  /**
   * Internal flag to indicate that the error was thrown during `.transform()`
   * and will be re-thrown on `.unwrap()`.
   */
  readonly _uncaught?: true;
}
type Res<T extends Val, E extends Val> = Ok<T> | Err<E>;
/**
 * All non-nullable values that also are not Promises nor Zod results.
 * It's useful for restricting Zod results to not return `null` or `undefined`.
 */
type RawValue<T extends Val> = Exclude<T, SafeParseReturnType<unknown, T> | Promise<unknown>>;
/**
 * Class for representing a result that can fail.
 *
 * The mental model:
 * - `.wrap()` and `.wrapNullable()` are sinks
 * - `.transform()` are pipes which can be chained
 * - `.unwrap()` is the point of consumption
 */
declare class Result<T extends Val, E extends Val = Error> {
  private readonly res;
  private constructor();
  static ok<T extends Val>(val: T): Result<T, never>;
  static err<E extends Val>(err: E): Result<never, E>;
  static _uncaught<E extends Val>(err: E): Result<never, E>;
  /**
   * Wrap a callback or promise in a Result in such a way that any thrown errors
   * are caught and wrapped with `Result.err()` (and hence never re-thrown).
   *
   * In case of a promise, the `AsyncResult` is returned.
   * Use `.unwrap()` to get the `Promise<Result<T, E>>` from `AsyncResult`.
   *
   *   ```ts
   *
   *   // SYNC
   *   const parse = (json: string) => Result.wrap(() => JSON.parse(json));
   *
   *   const { val, err } = parse('{"foo": "bar"}').unwrap();
   *   expect(val).toEqual({ foo: 'bar' });
   *   expect(err).toBeUndefined();
   *
   *   const { val, err } = parse('!!!').unwrap();
   *   expect(val).toBeUndefined();
   *   expect(err).toBeInstanceOf(SyntaxError);
   *
   *   // ASYNC
   *   const request = (url: string) => Result.wrap(http.get(url));
   *
   *   const { val, err } = await request('https://example.com').unwrap();
   *   expect(val).toBeString();
   *   expect(err).toBeUndefined();
   *
   *   ```
   */
  static wrap<T extends Val, Input = unknown>(zodResult: SafeParseReturnType<Input, T>): Result<T, ZodError<Input>>;
  static wrap<T extends Val, E extends Val = Error>(callback: () => RawValue<T>): Result<T, E>;
  static wrap<T extends Val, E extends Val = Error>(callback: () => Promise<RawValue<T>>): AsyncResult<T, E>;
  static wrap<T extends Val, E extends Val = Error, EE extends Val = never>(promise: Promise<Result<T, EE>>): AsyncResult<T, E | EE>;
  static wrap<T extends Val, E extends Val = Error>(promise: Promise<RawValue<T>>): AsyncResult<T, E>;
  /**
   * Similar to `Result.wrap()`, but helps to undo the billion dollar mistake by
   * replacing `null` or `undefined` with an error of provided type.
   *
   * Errors thrown inside the callback or promise are caught and wrapped with `Result.err()`,
   * hence never re-thrown.
   *
   * Since functions and promises returning nullable can't be wrapped with `Result.wrap()`
   * because `val` is constrained by being `NonNullable`, `null` and `undefined`
   * must be converted to some sort of `err` value.
   *
   * This method does exactly this, i.g. it is the feature-rich shorthand for:
   *
   *   ```ts
   *   const { val, err } = Result.wrap(() => {
   *     const result = callback();
   *     return result === null || result === undefined
   *       ? Result.err('oops')
   *       : Result.ok(result);
   *   }).unwrap();
   *   ```
   *
   * In case of a promise, the `AsyncResult` is returned.
   *
   *   ```ts
   *
   *   // SYNC
   *   const getHostname = (url: string) =>
   *     Result.wrapNullable(
   *       () => parseUrl(url)?.hostname,
   *       'invalid-url' as const
   *     );
   *   const { val, err } = getHostname('foobar').unwrap();
   *   expect(val).toBeUndefined();
   *   expect(err).toBe('invalid-url');
   *
   *   // ASYNC
   *   const { val, err } = await Result.wrapNullable(
   *     readLocalFile('yarn.lock'),
   *     'file-read-error' as const
   *   ).unwrap();
   *
   *   ```
   */
  static wrapNullable<T extends Val, E extends Val = Error, ErrForNullable extends Val = Error>(callback: () => Nullish<T>, errForNullable: ErrForNullable): Result<T, E | ErrForNullable>;
  static wrapNullable<T extends Val, E extends Val = Error, ErrForNull extends Val = Error, ErrForUndefined extends Val = Error>(callback: () => Nullish<T>, errForNull: ErrForNull, errForUndefined: ErrForUndefined): Result<T, E | ErrForNull | ErrForUndefined>;
  static wrapNullable<T extends Val, E extends Val = Error, ErrForNullable extends Val = Error>(promise: Promise<Nullish<T>>, errForNullable: ErrForNullable): AsyncResult<T, E | ErrForNullable>;
  static wrapNullable<T extends Val, E extends Val = Error, ErrForNull extends Val = Error, ErrForUndefined extends Val = Error>(promise: Promise<Nullish<T>>, errForNull: ErrForNull, errForUndefined: ErrForUndefined): AsyncResult<T, E | ErrForNull | ErrForUndefined>;
  static wrapNullable<T extends Val, E extends Val = Error, ErrForNullable extends Val = Error>(value: Nullish<T>, errForNullable: ErrForNullable): Result<T, E | ErrForNullable>;
  static wrapNullable<T extends Val, E extends Val = Error, ErrForNull extends Val = Error, ErrForUndefined extends Val = Error>(value: Nullish<T>, errForNull: ErrForNull, errForUndefined: ErrForUndefined): Result<T, E | ErrForNull | ErrForUndefined>;
  /**
   * Returns a discriminated union for type-safe consumption of the result.
   * When error was uncaught during transformation, it's being re-thrown here.
   *
   *   ```ts
   *
   *   const { val, err } = Result.ok('foo').unwrap();
   *   expect(val).toBe('foo');
   *   expect(err).toBeUndefined();
   *
   *   ```
   */
  unwrap(): Res<T, E>;
  /**
   * Returns a success value or a fallback value.
   * When error was uncaught during transformation, it's being re-thrown here.
   *
   *   ```ts
   *
   *   const value = Result.err('bar').unwrapOr('foo');
   *   expect(val).toBe('foo');
   *
   *   ```
   */
  unwrapOr(fallback: T): T;
  /**
   * Returns the ok-value or throw the error.
   */
  unwrapOrThrow(): T;
  /**
   * Returns the ok-value or `null`.
   * When error was uncaught during transformation, it's being re-thrown here.
   */
  unwrapOrNull(): T | null;
  /**
   * Transforms the ok-value, sync or async way.
   *
   * Transform functions SHOULD NOT throw.
   * Uncaught errors are logged and wrapped to `Result._uncaught()`,
   * which leads to re-throwing them in `unwrap()`.
   *
   * Zod `.safeParse()` results are converted automatically.
   *
   *   ```ts
   *
   *   // SYNC
   *   const { val, err } = Result.ok('foo')
   *     .transform((x) => x.length)
   *     .unwrap();
   *   expect(val).toBe(3);
   *
   *   // ASYNC
   *   const { val, err } = await Result.wrap(
   *     http.getJson('https://api.example.com/data.json')
   *   )
   *     .transform(({ body }) => body)
   *     .unwrap();
   *
   *   ```
   */
  transform<U extends Val, EE extends Val>(fn: (value: T) => Result<U, E | EE>): Result<U, E | EE>;
  transform<U extends Val, EE extends Val>(fn: (value: T) => AsyncResult<U, E | EE>): AsyncResult<U, E | EE>;
  transform<U extends Val, Input = unknown>(fn: (value: T) => SafeParseReturnType<Input, NonNullable<U>>): Result<U, E | ZodError<Input>>;
  transform<U extends Val, Input = unknown>(fn: (value: T) => Promise<SafeParseReturnType<Input, NonNullable<U>>>): AsyncResult<U, E | ZodError<Input>>;
  transform<U extends Val, EE extends Val>(fn: (value: T) => Promise<Result<U, E | EE>>): AsyncResult<U, E | EE>;
  transform<U extends Val>(fn: (value: T) => Promise<RawValue<U>>): AsyncResult<U, E>;
  transform<U extends Val>(fn: (value: T) => RawValue<U>): Result<U, E>;
  catch<U extends Val = T, EE extends Val = E>(fn: (err: E) => Result<U, EE>): Result<T | U, EE>;
  catch<U extends Val = T, EE extends Val = E>(fn: (err: E) => AsyncResult<U, EE>): AsyncResult<T | U, EE>;
  catch<U extends Val = T, EE extends Val = E>(fn: (err: E) => Promise<Result<U, EE>>): AsyncResult<T | U, EE>;
  /**
   * Given a `schema` and `input`, returns a `Result` with `val` being the parsed value.
   * Additionally, `null` and `undefined` values are converted into Zod error.
   */
  static parse<Schema extends ZodType<any, any, any>>(input: unknown, schema: Schema): Result<NonNullable<output<Schema>>, ZodError<input<Schema>>>;
  /**
   * Given a `schema`, returns a `Result` with `val` being the parsed value.
   * Additionally, `null` and `undefined` values are converted into Zod error.
   */
  parse<Schema extends ZodType<any, any, any>>(schema: Schema): Result<NonNullable<output<Schema>>, E | ZodError<input<Schema>>>;
  /**
   * Call `fn` on the `val` if the result is ok.
   */
  onValue(fn: (value: T) => void): Result<T, E>;
  /**
   * Call `fn` on the `err` if the result is err.
   */
  onError(fn: (err: E) => void): Result<T, E>;
}
/**
 * This class is being used when `Result` methods encounter async code.
 * It isn't meant to be used directly, but exported for usage in type annotations.
 *
 * All the methods resemble `Result` methods, but work asynchronously.
 */
declare class AsyncResult<T extends Val, E extends Val> implements PromiseLike<Result<T, E>> {
  private asyncResult;
  private constructor();
  then<TResult1 = Result<T, E>>(onfulfilled?: ((value: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | null): PromiseLike<TResult1>;
  static ok<T extends Val>(val: T): AsyncResult<T, never>;
  static err<E extends Val>(err: NonNullable<E>): AsyncResult<never, E>;
  static wrap<T extends Val, E extends Val = Error, EE extends Val = never, Input = unknown>(promise: Promise<SafeParseReturnType<Input, T>> | Promise<Result<T, EE>> | Promise<RawValue<T>>, onErr?: (err: NonNullable<E>) => Result<T, E>): AsyncResult<T, E | EE>;
  static wrapNullable<T extends Val, E extends Val, ErrForNull extends Val, ErrForUndefined extends Val>(promise: Promise<Nullish<T>>, errForNull: NonNullable<ErrForNull>, errForUndefined: NonNullable<ErrForUndefined>): AsyncResult<T, E | ErrForNull | ErrForUndefined>;
  /**
   * Returns a discriminated union for type-safe consumption of the result.
   *
   *   ```ts
   *
   *   const { val, err } = await Result.wrap(readFile('foo.txt')).unwrap();
   *   expect(val).toBe('foo');
   *   expect(err).toBeUndefined();
   *
   *   ```
   */
  unwrap(): Promise<Res<T, E>>;
  /**
   * Returns a success value or a fallback value.
   *
   *   ```ts
   *
   *   const val = await Result.wrap(readFile('foo.txt')).unwrapOr('bar');
   *   expect(val).toBe('bar');
   *   expect(err).toBeUndefined();
   *
   *   ```
   */
  unwrapOr(fallback: T): Promise<T>;
  /**
   * Returns the ok-value or throw the error.
   */
  unwrapOrThrow(): Promise<T>;
  /**
   * Returns the ok-value or `null`.
   */
  unwrapOrNull(): Promise<T | null>;
  /**
   * Transforms the ok-value, sync or async way.
   *
   * Transform functions SHOULD NOT throw.
   * Uncaught errors are logged and wrapped to `Result._uncaught()`,
   * which leads to re-throwing them in `unwrap()`.
   *
   * Zod `.safeParse()` results are converted automatically.
   *
   *   ```ts
   *
   *   const { val, err } = await Result.wrap(
   *     http.getJson('https://api.example.com/data.json')
   *   )
   *     .transform(({ body }) => body)
   *     .unwrap();
   *
   *   ```
   */
  transform<U extends Val, EE extends Val>(fn: (value: T) => Result<U, E | EE>): AsyncResult<U, E | EE>;
  transform<U extends Val, EE extends Val>(fn: (value: T) => AsyncResult<U, E | EE>): AsyncResult<U, E | EE>;
  transform<U extends Val, Input = unknown>(fn: (value: T) => SafeParseReturnType<Input, NonNullable<U>>): AsyncResult<U, E | ZodError<Input>>;
  transform<U extends Val, Input = unknown>(fn: (value: T) => Promise<SafeParseReturnType<Input, NonNullable<U>>>): AsyncResult<U, E | ZodError<Input>>;
  transform<U extends Val, EE extends Val>(fn: (value: T) => Promise<Result<U, E | EE>>): AsyncResult<U, E | EE>;
  transform<U extends Val>(fn: (value: T) => Promise<RawValue<U>>): AsyncResult<U, E>;
  transform<U extends Val>(fn: (value: T) => RawValue<U>): AsyncResult<U, E>;
  catch<U extends Val = T, EE extends Val = E>(fn: (err: NonNullable<E>) => Result<U, EE>): AsyncResult<T | U, EE>;
  catch<U extends Val = T, EE extends Val = E>(fn: (err: NonNullable<E>) => AsyncResult<U, EE>): AsyncResult<T | U, EE>;
  catch<U extends Val = T, EE extends Val = E>(fn: (err: NonNullable<E>) => Promise<Result<U, EE>>): AsyncResult<T | U, EE>;
  /**
   * Given a `schema`, returns a `Result` with `val` being the parsed value.
   * Additionally, `null` and `undefined` values are converted into Zod error.
   */
  parse<Schema extends ZodType<any, any, any>>(schema: Schema): AsyncResult<NonNullable<output<Schema>>, E | ZodError<input<Schema>>>;
  onValue(fn: (value: T) => void): AsyncResult<T, E>;
  onError(fn: (err: E) => void): AsyncResult<T, E>;
}
//#endregion
export { AsyncResult };
//# sourceMappingURL=result.d.ts.map