type RemoteData<E, A> = NotAsked | Loading | Success<A> | Failure<E>;

export declare const apFirst: <E, B>(
  second: RemoteData<E, B>,
) => <A>(first: RemoteData<E, A>) => RemoteData<E, A>;

export declare const apS: <N, A, E, B>(
  name: Exclude<N, keyof A>,
  fb: RemoteData<E, B>,
) => (
  fa: RemoteData<E, A>,
) => RemoteData<
  E,
  { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }
>;

export declare const apSecond: <E, B>(
  second: RemoteData<E, B>,
) => <A>(first: RemoteData<E, A>) => RemoteData<E, B>;

export declare const bind: <N, A, E, B>(
  name: Exclude<N, keyof A>,
  f: (a: A) => RemoteData<E, B>,
) => (
  ma: RemoteData<E, A>,
) => RemoteData<
  E,
  { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }
>;

export declare const bindTo: <N>(
  name: N,
) => <E, A>(fa: RemoteData<E, A>) => RemoteData<E, { readonly [K in N]: A }>;

export declare const chainFirst: <A, E, B>(
  f: (a: A) => RemoteData<E, B>,
) => (first: RemoteData<E, A>) => RemoteData<E, A>;

export declare const filterOrElse: {
  <A, B, E>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (
    ma: RemoteData<E, A>,
  ) => RemoteData<E, B>;
  <A, E>(predicate: Predicate<A>, onFalse: (a: A) => E): <B>(
    mb: RemoteData<E, B>,
  ) => RemoteData<E, B>;
  <A, E>(predicate: Predicate<A>, onFalse: (a: A) => E): (
    ma: RemoteData<E, A>,
  ) => RemoteData<E, A>;
};

export declare const flap: <A>(
  a: A,
) => <E, B>(fab: RemoteData<E, (a: A) => B>) => RemoteData<E, B>;

export declare const flatten: <E, A>(
  mma: RemoteData<E, RemoteData<E, A>>,
) => RemoteData<E, A>;

export declare const mapFailure: <E, G>(
  f: (a: E) => G,
) => <A>(rda: RemoteData<E, A>) => RemoteData<G, A>;

export declare const swap: <E = unknown, A = unknown>(
  rda: RemoteData<E, A>,
) => RemoteData<A, E>;

export declare const failure: <E = unknown>(error: E) => RemoteData<E, never>;

export declare const fromPredicate: {
  <A, B, E>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (
    a: A,
  ) => RemoteData<E, B>;
  <A, E>(predicate: Predicate<A>, onFalse: (a: A) => E): <B>(
    b: B,
  ) => RemoteData<E, B>;
  <A, E>(predicate: Predicate<A>, onFalse: (a: A) => E): (
    a: A,
  ) => RemoteData<E, A>;
};

export declare const loading: RemoteData<never, never>;

export declare const notAsked: RemoteData<never, never>;

export declare const of: <D = unknown>(data: D) => RemoteData<never, D>;

export declare const success: <D = unknown>(data: D) => RemoteData<never, D>;

export declare const getOrElse: <E = unknown, A = unknown>(
  onNotAsked: () => A,
  onLoading: () => A,
  onFailure: (err: E) => A,
) => (rda: RemoteData<E, A>) => A;

export declare const match: <E = unknown, D = unknown, R = unknown>(matcher: {
  notAsked: () => R;
  loading: () => R;
  success: (data: D) => R;
  failure: (error: E) => R;
}) => (rd: RemoteData<E, D>) => R;

export declare const toNullable: <E = unknown, A = unknown>(
  rda: RemoteData<E, A>,
) => A | null;

export declare const alt: <E, A>(
  that: Lazy<RemoteData<E, A>>,
) => (fa: RemoteData<E, A>) => RemoteData<E, A>;

export declare const ap: <E, A>(
  rda: RemoteData<E, A>,
) => <B>(rdfab: RemoteData<E, (a: A) => B>) => RemoteData<E, B>;

export declare const bimap: <E, A, G, B>(
  f: (e: E) => G,
  g: (a: A) => B,
) => (rdea: RemoteData<E, A>) => RemoteData<G, B>;

export declare const chain: <E, A, B>(
  f: (a: A) => RemoteData<E, B>,
) => (rda: RemoteData<E, A>) => RemoteData<E, B>;

export declare const foldMap: <M>(
  M: Monoid<M>,
) => <A>(f: (a: A) => M) => <E>(rda: RemoteData<E, A>) => M;

export declare const map: <A, B>(
  f: (a: A) => B,
) => <E>(rda: RemoteData<E, A>) => RemoteData<E, B>;

export declare const mapLeft: <E, G>(
  f: (a: E) => G,
) => <A>(rda: RemoteData<E, A>) => RemoteData<G, A>;

export declare const reduce: <E, A, B>(
  b: B,
  f: (b: B, a: A) => B,
) => (rda: RemoteData<E, A>) => B;

export declare const reduceRight: <E, A, B>(
  b: B,
  f: (a: A, b: B) => B,
) => (rda: RemoteData<E, A>) => B;

export declare const sequence: Sequence2<'RemoteData'>;

export declare const traverse: PipeableTraverse2<'RemoteData'>;

export declare const Alt: Alt2<'RemoteData'>;

export declare const Applicative: Applicative2<'RemoteData'>;

export declare const Apply: Apply2<'RemoteData'>;

export declare const Bifunctor: Bifunctor2<'RemoteData'>;

export declare const Chain: Chain2<'RemoteData'>;

export declare const Foldable: Foldable2<'RemoteData'>;

export declare const FromEither: FromEither2<'RemoteData'>;

export declare const Functor: Functor2<'RemoteData'>;

export declare const Monad: Monad2<'RemoteData'>;

export declare const MonadThrow: MonadThrow2<'RemoteData'>;

export declare const Traversable: Traversable2<'RemoteData'>;

export declare const URI: 'RemoteData';

export type URI = typeof URI;

export declare function getEq<E, A>(
  eqErr: Eq<E>,
  eqA: Eq<A>,
): Eq<RemoteData<E, A>>;

export declare function getOrd<E, A>(
  ordErr: Ord<E>,
  ordA: Ord<A>,
): Ord<RemoteData<E, A>>;

export interface Failure<E = unknown> {
  readonly tag: 'Failure';
  readonly error: E;
}

export interface Loading {
  readonly tag: 'Loading';
}

export interface NotAsked {
  readonly tag: 'NotAsked';
}

export type RemoteData<E = unknown, A = unknown> =
  | NotAsked
  | Loading
  | Failure<E>
  | Success<A>;

export interface Success<A = unknown> {
  readonly tag: 'Success';
  readonly data: A;
}

export declare const fromOption: <E>(
  onNone: Lazy<E>,
) => NaturalTransformation12C<'Option', 'RemoteData', E>;

export declare const toEither: <E = unknown, L = unknown>(
  onNotAsked: () => L,
  onLoading: () => L,
  onFailure: (err: E) => L,
) => <A = unknown>(rda: RemoteData<E, A>) => E.Either<L, A>;

export declare const toOption: <E = unknown, A = unknown>(
  rda: RemoteData<E, A>,
) => O.Option<NonNullable<A>>;

export declare const isFailure: (
  rd: RemoteData<unknown, unknown>,
) => rd is Failure<unknown>;

export declare const isLoading: (
  rd: RemoteData<unknown, unknown>,
) => rd is Loading;

export declare const isNotAsked: (
  rd: RemoteData<unknown, unknown>,
) => rd is NotAsked;

export declare const isSuccess: (
  rd: RemoteData<unknown, unknown>,
) => rd is Success<unknown>;

export declare const elem: <A = unknown>(
  E: Eq<A>,
) => <E = unknown>(a: A, rda: RemoteData<E, A>) => boolean;

export declare const exists: <A = unknown>(
  predicate: Predicate<A>,
) => <E = unknown>(rda: RemoteData<E, A>) => boolean;