/**
 * A Computation is a way to chain consecutive operations while collecting logs. It's
 * useful for guarding against unwanted input conditions, and is used in this libary for
 * matrix decomposition.
 *
 * @since 1.0.0
 */
import * as Apl from 'fp-ts/Applicative';
import * as Ap from 'fp-ts/Apply';
import * as BiFun from 'fp-ts/Bifunctor';
import * as Chn from 'fp-ts/Chain';
import * as E from 'fp-ts/Either';
import * as IO from 'fp-ts/IO';
import * as FE from 'fp-ts/FromEither';
import * as Fun from 'fp-ts/Functor';
import * as Mon from 'fp-ts/Monad';
import * as MonThrow from 'fp-ts/MonadThrow';
import * as O from 'fp-ts/Option';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type Computation<E, A> = readonly [E.Either<E, A>, ReadonlyArray<E>];
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const of: <A>(value: A) => Computation<never, A>;
/**
 * @since 1.1.0
 * @category Destructors
 */
export declare const runComputation: <E, A>(c: Computation<E, A>) => E.Either<E, A>;
/**
 * @since 1.1.0
 * @category Destructors
 */
export declare const runLogs: <E, O>(f: (e: E) => IO.IO<O>) => <A>(c: Computation<E, A>) => IO.IO<ReadonlyArray<O>>;
/**
 * @since 1.1.0
 * @category Destructors
 */
export declare const getOrThrow: <E>(onError: (e: E) => string) => <A>(c: Computation<E, A>) => A;
/**
 * @since 1.1.0
 * @category Destructors
 */
export declare const getOrThrowS: <A>(c: Computation<string, A>) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const URI = "Computation";
/**
 * @since 1.0.0
 * @category Instances
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind2<E, A> {
        readonly [URI]: Computation<E, A>;
    }
}
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: Computation<E, A>) => Computation<E, B>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Functor: Fun.Functor2<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fa: Computation<E, A>) => Computation<G, B>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: Computation<E, A>) => Computation<G, A>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Bifunctor: BiFun.Bifunctor2<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const ap: <E, A, B>(fab: Computation<E, (a: A) => B>) => (fa: Computation<E, A>) => Computation<E, B>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const Apply: Ap.Apply2<URI>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Applicative: Apl.Applicative2<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const chainW: <E1, E2, A, B>(f: (a: A) => Computation<E1, B>) => ([fa, logs]: Computation<E2, A>) => Computation<E1 | E2, B>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const chain: <E, A, B>(f: (a: A) => Computation<E, B>) => (fa: Computation<E, A>) => Computation<E, B>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Chain: Chn.Chain2<URI>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Monad: Mon.Monad2<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const throwError: <E>(e: E) => Computation<E, never>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const MonadThrow: MonThrow.MonadThrow2<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const fromEither: FE.FromEither2<URI>['fromEither'];
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const FromEither: FE.FromEither2<URI>;
/**
 * @since 1.0.0
 * @category Natural Transformations
 */
export declare const fromOption: <E>(onNone: import("fp-ts/function").Lazy<E>) => import("fp-ts/lib/NaturalTransformation").NaturalTransformation12C<"Option", "Computation", E>;
/**
 * @since 1.1.0
 * @category Natural Transformations
 */
export declare const toOption: <E, A>(c: Computation<E, A>) => O.Option<A>;
/**
 * @since 1.1.0
 * @category Natural Transformations
 */
export declare const fromPredicate: {
    <A, B extends A, E>(refinement: import("fp-ts/lib/Refinement").Refinement<A, B>, onFalse: (a: A) => E): (a: A) => Computation<E, B>;
    <A_1, E_1>(predicate: import("fp-ts/lib/Predicate").Predicate<A_1>, onFalse: (a: A_1) => E_1): <B_1 extends A_1>(b: B_1) => Computation<E_1, B_1>;
    <A_2, E_2>(predicate: import("fp-ts/lib/Predicate").Predicate<A_2>, onFalse: (a: A_2) => E_2): (a: A_2) => Computation<E_2, A_2>;
};
/**
 * @since 1.0.0
 * @category Refinements
 */
export declare const isLeft: <E, A>(e: Computation<E, A>) => e is readonly [E.Left<E>, readonly E[]];
/**
 * @since 1.0.0
 * @category Refinements
 */
export declare const isRight: <E, A>(e: Computation<E, A>) => e is readonly [E.Right<A>, readonly E[]];
/**
 * @since 1.0.0
 * @category Combinators
 */
export declare const apFirst: <E, B>(second: Computation<E, B>) => <A>(first: Computation<E, A>) => Computation<E, A>;
/**
 * @since 1.0.0
 * @category Combinators
 */
export declare const apSecond: <E, B>(second: Computation<E, B>) => <A>(first: Computation<E, A>) => Computation<E, B>;
/**
 * @since 1.0.0
 * @category Combinators
 */
export declare const chainFirst: <A, E, B>(f: (a: A) => Computation<E, B>) => (first: Computation<E, A>) => Computation<E, A>;
/**
 * @since 1.0.0
 * @category Combinators
 */
export declare const chainOptionK: <E>(onNone: import("fp-ts/function").Lazy<E>) => <A, B>(f: (a: A) => O.Option<B>) => (ma: Computation<E, A>) => Computation<E, B>;
/**
 * @since 1.0.0
 * @category Combinators
 */
export declare const chainEitherK: <A, E, B>(f: (a: A) => E.Either<E, B>) => (ma: Computation<E, A>) => Computation<E, B>;
/**
 * @since 1.0.0
 * @category Utilities
 */
export declare const tell: <E>(message: E) => Computation<E, void>;
/**
 * @since 1.0.0
 * @category Utilities
 */
export declare const log: <E>(message: E) => <A>(fa: Computation<E, A>) => Computation<E, A>;
/**
 * Log one message on left, and a different on right
 *
 * @since 1.1.0
 * @category Utilities
 */
export declare const bilog: <E>(onLeft: () => E, onRight: () => E) => <A>(fa: Computation<E, A>) => Computation<E, A>;
/**
 * @since 1.0.0
 * @category Utilities
 */
export declare const logOption: <E, A>(getOptionalMesasge: (a: A) => O.Option<E>) => (fa: Computation<E, A>) => Computation<E, A>;
/**
 * @since 1.0.0
 * @category Utilities
 */
export declare const filter: <E, A>(predicate: (a: A) => boolean, onFalse: (a: A) => E) => (fa: Computation<E, A>) => Computation<E, A>;
/**
 * @since 1.0.0
 * @category Utilities
 */
export declare const filterOptionK: <E, A, B>(test: (a: A) => O.Option<B>, onFalse: (a: A) => E) => (a: A) => Computation<E, B>;
/**
 * @since 1.0.0
 * @category Do Notation
 */
export declare const Do: Computation<never, {}>;
/**
 * @since 1.0.0
 * @category Do Notation
 */
export declare const apS: <N extends string, 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; }>;
/**
 * @since 1.0.0
 * @category Do Notation
 */
export declare const bindTo: <N extends string>(name: N) => <E, A>(fa: Computation<E, A>) => Computation<E, { readonly [K in N]: A; }>;
/**
 * @since 1.0.0
 * @category Do Notation
 */
export declare const bind: <N extends string, 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; }>;
/**
 * @since 1.0.0
 * @category Do Notation
 */
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<E1 | E2, {
    readonly [K in keyof A | N]: K extends keyof A ? A[K] : B;
}>;
//# sourceMappingURL=Computation.d.ts.map