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

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

export declare const chainEitherK: <A, E, B>(
  f: (a: A) => E.Either<E, B>
) => (ma: Computation<E, A>) => Computation<E, B>

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

export declare const chainOptionK: <E>(
  onNone: Lazy<E>
) => <A, B>(f: (a: A) => O.Option<B>) => (ma: Computation<E, A>) => Computation<E, B>

export declare const of: <A>(value: A) => Computation<never, A>

export declare const getOrThrow: <E>(onError: (e: E) => string) => <A>(c: Computation<E, A>) => A

export declare const getOrThrowS: <A>(c: Computation<string, A>) => A

export declare const runComputation: <E, A>(c: Computation<E, A>) => E.Either<E, A>

export declare const runLogs: <E, O>(f: (e: E) => IO.IO<O>) => <A>(c: Computation<E, A>) => IO.IO<readonly O[]>

export declare const Do: Computation<never, {}>

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

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

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

export declare const bindW: <N extends string, A, E2, B>(
  name: Exclude<N, keyof A>,
  f: (a: A) => Computation<E2, B>
) => <E1>(fa: Computation<E1, A>) => Computation<E2 | E1, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>

export declare const Apply: Ap.Apply2<'Computation'>

export declare const ap: <E, A, B>(fab: Computation<E, (a: A) => B>) => (fa: Computation<E, A>) => Computation<E, B>

export declare const bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fa: Computation<E, A>) => Computation<G, B>

export declare const chain: <E, A, B>(f: (a: A) => Computation<E, B>) => (fa: Computation<E, A>) => Computation<E, B>

export declare const chainW: <E1, E2, A, B>(
  f: (a: A) => Computation<E1, B>
) => ([fa, logs]: Computation<E2, A>) => Computation<E1 | E2, B>

export declare const fromEither: NaturalTransformation22<'Either', 'Computation'>

export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: Computation<E, A>) => Computation<E, B>

export declare const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: Computation<E, A>) => Computation<G, A>

export declare const throwError: <E>(e: E) => Computation<E, never>

export declare const Applicative: Apl.Applicative2<'Computation'>

export declare const Bifunctor: BiFun.Bifunctor2<'Computation'>

export declare const Chain: Chn.Chain2<'Computation'>

export declare const FromEither: FE.FromEither2<'Computation'>

export declare const Functor: Fun.Functor2<'Computation'>

export declare const Monad: Mon.Monad2<'Computation'>

export declare const MonadThrow: MonThrow.MonadThrow2<'Computation'>

export declare const URI: 'Computation'

export type URI = typeof URI

export type Computation<E, A> = readonly [E.Either<E, A>, ReadonlyArray<E>]

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

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

export declare const toOption: <E, A>(c: Computation<E, A>) => O.Option<A>

export declare const isLeft: <E, A>(e: Computation<E, A>) => e is readonly [E.Left<E>, readonly E[]]

export declare const isRight: <E, A>(e: Computation<E, A>) => e is readonly [E.Right<A>, readonly E[]]

export declare const bilog: <E>(onLeft: () => E, onRight: () => E) => <A>(fa: Computation<E, A>) => Computation<E, A>

export declare const filter: <E, A>(
  predicate: (a: A) => boolean,
  onFalse: (a: A) => E
) => (fa: Computation<E, A>) => Computation<E, A>

export declare const filterOptionK: <E, A, B>(
  test: (a: A) => O.Option<B>,
  onFalse: (a: A) => E
) => (a: A) => Computation<E, B>

export declare const log: <E>(message: E) => <A>(fa: Computation<E, A>) => Computation<E, A>

export declare const logOption: <E, A>(
  getOptionalMesasge: (a: A) => O.Option<E>
) => (fa: Computation<E, A>) => Computation<E, A>

export declare const tell: <E>(message: E) => Computation<E, void>