export declare const cause: <A, E>(self: Result<A, E>) => Option.Option<Cause.Cause<E>>

export declare const getOrElse: {
  <B>(orElse: LazyArg<B>): <A, E>(self: Result<A, E>) => A | B
  <A, E, B>(self: Result<A, E>, orElse: LazyArg<B>): A | B
}

export declare const getOrThrow: <A, E>(self: Result<A, E>) => A

export declare const value: <A, E>(self: Result<A, E>) => Option.Option<A>

export declare const map: {
  <A, B>(f: (a: A) => B): <E>(self: Result<A, E>) => Result<B, E>
  <E, A, B>(self: Result<A, E>, f: (a: A) => B): Result<B, E>
}

export declare const match: {
  <A, E, X, Y, Z>(options: {
    readonly onInitial: (_: Initial<A, E>) => X
    readonly onFailure: (_: Failure<A, E>) => Y
    readonly onSuccess: (_: Success<A, E>) => Z
  }): (self: Result<A, E>) => X | Y | Z
  <A, E, X, Y, Z>(
    self: Result<A, E>,
    options: {
      readonly onInitial: (_: Initial<A, E>) => X
      readonly onFailure: (_: Failure<A, E>) => Y
      readonly onSuccess: (_: Success<A, E>) => Z
    }
  ): X | Y | Z
}

export declare const matchWithError: {
  <A, E, W, X, Y, Z>(options: {
    readonly onInitial: (_: Initial<A, E>) => W
    readonly onError: (error: E, _: Failure<A, E>) => X
    readonly onDefect: (defect: unknown, _: Failure<A, E>) => Y
    readonly onSuccess: (_: Success<A, E>) => Z
  }): (self: Result<A, E>) => W | X | Y | Z
  <A, E, W, X, Y, Z>(
    self: Result<A, E>,
    options: {
      readonly onInitial: (_: Initial<A, E>) => W
      readonly onError: (error: E, _: Failure<A, E>) => X
      readonly onDefect: (defect: unknown, _: Failure<A, E>) => Y
      readonly onSuccess: (_: Success<A, E>) => Z
    }
  ): W | X | Y | Z
}

export declare const matchWithWaiting: {
  <A, E, W, X, Y, Z>(options: {
    readonly onWaiting: (_: Result<A, E>) => W
    readonly onError: (error: E, _: Failure<A, E>) => X
    readonly onDefect: (defect: unknown, _: Failure<A, E>) => Y
    readonly onSuccess: (_: Success<A, E>) => Z
  }): (self: Result<A, E>) => W | X | Y | Z
  <A, E, W, X, Y, Z>(
    self: Result<A, E>,
    options: {
      readonly onWaiting: (_: Result<A, E>) => W
      readonly onError: (error: E, _: Failure<A, E>) => X
      readonly onDefect: (defect: unknown, _: Failure<A, E>) => Y
      readonly onSuccess: (_: Success<A, E>) => Z
    }
  ): W | X | Y | Z
}

export declare const toExit: <A, E>(self: Result<A, E>) => Exit.Exit<A, E | Cause.NoSuchElementException>

export declare const fail: <A, E>(error: E, previousData?: Option.Option<A>, waiting?: boolean) => Failure<A, E>

export declare const failWithPrevious: <A, E>(
  error: E,
  previous: Option.Option<Result<A, E>>,
  waiting?: boolean
) => Failure<A, E>

export declare const failure: <A, E>(
  cause: Cause.Cause<E>,
  previousValue?: Option.Option<A>,
  waiting?: boolean
) => Failure<A, E>

export declare const failureWithPrevious: <A, E>(
  cause: Cause.Cause<E>,
  previous: Option.Option<Result<A, E>>,
  waiting?: boolean
) => Failure<A, E>

export declare const fromExit: <A, E>(exit: Exit.Exit<A, E>) => Success<A, E> | Failure<A, E>

export declare const fromExitWithPrevious: <A, E>(
  exit: Exit.Exit<A, E>,
  previous: Option.Option<Result<A, E>>
) => Success<A, E> | Failure<A, E>

export declare const initial: <A, E>(waiting?: boolean) => Initial<A, E>

export declare const replacePrevious: <R extends Result<any, any>, XE, A>(
  self: R,
  previous: Option.Option<Result<A, XE>>
) => Result.With<R, A, Result.InferE<R>>

export declare const success: <A, E>(value: A, waiting?: boolean) => Success<A, E>

export declare const waiting: <R extends Result<any, any>>(self: R) => R

export declare const waitingFrom: <A, E>(previous: Option.Option<Result<A, E>>) => Result<A, E>

export interface Failure<A, E = never> extends Result.Proto<A, E> {
  readonly _tag: "Failure"
  readonly cause: Cause.Cause<E>
  readonly previousValue: Option.Option<A>
}

export interface Initial<A, E = never> extends Result.Proto<A, E> {
  readonly _tag: "Initial"
}

export type Result<A, E = never> = Initial<A, E> | Success<A, E> | Failure<A, E>

export interface Proto<A, E> extends Pipeable {
  readonly [TypeId]: {
    readonly E: (_: never) => E
    readonly A: (_: never) => A
  }
  readonly waiting: boolean
}

export type InferA<R extends Result<any, any>> = R extends Result<infer A, infer _> ? A : never

export type InferE<R extends Result<any, any>> = R extends Result<infer _, infer E> ? E : never

export type With<R extends Result<any, any>, A, E> =
  R extends Initial<infer _A, infer _E>
    ? Initial<A, E>
    : R extends Success<infer _A, infer _E>
      ? Success<A, E>
      : R extends Failure<infer _A, infer _E>
        ? Failure<A, E>
        : never

export interface Success<A, E = never> extends Result.Proto<A, E> {
  readonly _tag: "Success"
  readonly value: A
}

export declare const isFailure: <A, E>(result: Result<A, E>) => result is Failure<A, E>

export declare const isInitial: <A, E>(result: Result<A, E>) => result is Initial<A, E>

export declare const isInterrupted: <A, E>(result: Result<A, E>) => result is Failure<A, E>

export declare const isNotInitial: <A, E>(result: Result<A, E>) => result is Success<A, E> | Failure<A, E>

export declare const isSuccess: <A, E>(result: Result<A, E>) => result is Success<A, E>

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId