import * as tOf from '../../typeclass/of';
import * as tFunctor from '../../typeclass/functor';
import * as tBiFunctor from '../../typeclass/bifunctor';
import * as tApplicative from '../../typeclass/applicative';
import * as tSemiAlternative from '../../typeclass/semialternative';
import * as tMonad from '../../typeclass/monad';
import * as tBiFlatMap from '../../typeclass/biflatmap';
import type { Effect, TEffect } from './effect.types';
import * as O from '../option';
import * as R from '../result';
import * as IO from '../io';
import * as IOO from '../io-option';
import * as IOR from '../io-result';
import * as A from '../async';
import * as AO from '../async-option';
import * as AR from '../async-result';
import * as T from '../task';
import * as TO from '../task-option';
import * as TR from '../task-result';
import * as RIO from '../reader-io';
import * as RIOO from '../reader-io-option';
import * as RIOR from '../reader-io-result';
import * as RT from '../reader-task';
import * as RTO from '../reader-task-option';
export declare const ask: <E, Env>() => Effect<Env, E, Env>;
export declare const asks: <A, E, Env>(f: (env: Env) => A) => Effect<A, E, Env>;
export declare const local: <Env1, Env2>(f: (env: Env2) => Env1) => <A, E>(fa: Effect<A, E, Env1>) => Effect<A, E, Env2>;
export declare const askReader: <Env1, Env2, A, E>(f: (env: Env1) => Effect<A, E, Env2>) => Effect<A, E, Env1 & Env2>;
export declare const ok: <A, E = never, Env = unknown>(a: A) => Effect<A, E, Env>;
export declare const err: <E, A = never, Env = unknown>(e: E) => Effect<A, E, Env>;
export declare const Of: tOf.Of<TEffect>;
export declare const Functor: tFunctor.Functor<TEffect>;
export declare const BiFunctor: tBiFunctor.BiFunctor<TEffect>;
export declare const Applicative: tApplicative.Applicative<TEffect>;
export declare const Monad: tMonad.Monad<TEffect>;
export declare const BiFlatMap: tBiFlatMap.BiFlatMap<TEffect>;
export declare const SemiAlternative: tSemiAlternative.SemiAlternative<TEffect>;
/******************************
 *  Context free constructors *
 ******************************/
export declare const fromOption: <A, E = never, Env = unknown>(onErr: () => E) => (o: O.Option<A>) => Effect<A, E, Env>;
export declare const fromResult: <A, E, Env = unknown>(r: R.Result<A, E>) => Effect<A, E, Env>;
export declare const fromIO: <A, E = never, Env = unknown>(io: IO.IO<A>) => Effect<A, E, Env>;
export declare const fromIOOption: <A, E = never, Env = unknown>(onErr: () => E) => (ioo: IOO.IOOption<A>) => Effect<A, E, Env>;
export declare const fromIOResult: <A, E, Env = unknown>(ior: IOR.IOResult<A, E>) => Effect<A, E, Env>;
export declare const fromAsync: <A, E = never, Env = unknown>(a: A.Async<A>) => Effect<A, E, Env>;
export declare const fromAsyncOption: <A, E = never, Env = unknown>(onErr: () => E) => (ao: AO.AsyncOption<A>) => Effect<A, E, Env>;
export declare const fromAsyncResult: <A, E, Env = unknown>(ar: AR.AsyncResult<A, E>) => Effect<A, E, Env>;
export declare const fromTask: <A, E = never, Env = unknown>(io: T.Task<A>) => Effect<A, E, Env>;
export declare const fromTaskOption: <A, E = never, Env = unknown>(onErr: () => E) => (aioo: TO.TaskOption<A>) => Effect<A, E, Env>;
export declare const fromTaskResult: <A, E, Env = unknown>(aior: TR.TaskResult<A, E>) => Effect<A, E, Env>;
/******************************
 * Context aware constructors *
 ******************************/
export declare const fromReader: <A, E = never, Env = unknown>(f: (env: Env) => A) => Effect<A, E, Env>;
export declare const fromReaderIO: <A, E = never, Env = unknown>(io: RIO.ReaderIO<A, Env>) => Effect<A, E, Env>;
export declare const fromReaderIOOption: <A, E = never, Env = unknown>(onErr: () => E) => (ioo: RIOO.ReaderIOOption<A, Env>) => Effect<A, E, Env>;
export declare const fromReaderIOResult: <A, E, Env = unknown>(ior: RIOR.ReaderIOResult<A, E, Env>) => Effect<A, E, Env>;
export declare const fromAsyncReader: <A, E = never, Env = unknown>(f: (env: Env) => A.Async<A>) => Effect<A, E, Env>;
export declare const fromReaderTask: <A, E = never, Env = unknown>(io: RT.ReaderTask<A, Env>) => Effect<A, E, Env>;
export declare const fromReaderTaskOption: <A, E = never, Env = unknown>(onErr: () => E) => (ioo: RTO.ReaderTaskOption<A, Env>) => Effect<A, E, Env>;
export declare const tryCatch: <A, E1, Env>($catch: (e: unknown) => E1) => <E2>(fa: Effect<A, E2, Env>) => Effect<A, E1 | E2, Env>;
export declare const of: <A>(a: A) => Effect<A, never, unknown>;
export declare const map: <A1, A2>(args_0: (args_0: A1) => A2) => <B1, B2>(args_0: Effect<A1, B1, B2>) => Effect<A2, B1, B2>;
export declare const mapCompose: <A1, A2>(args_0: (args_0: A1) => A2) => <B1, B2, B3, B4>(args_0: Effect<Effect<A1, B1, B2>, B3, B4>) => Effect<Effect<A2, B1, B2>, B3, B4>;
export declare const flap: <A1>(args_0: A1) => <B1, B2, B3>(args_0: Effect<(args_0: A1) => B1, B2, B3>) => Effect<B1, B2, B3>;
export declare const as: <A1>(args_0: A1) => <B1, B2, B3>(args_0: Effect<B1, B2, B3>) => Effect<A1, B2, B3>;
export declare const tap: <A1>(args_0: (args_0: A1) => void) => <B1, B2>(args_0: Effect<A1, B1, B2>) => Effect<A1, B1, B2>;
export declare const bimap: <A1, A2, A3, A4>(args_0: (args_0: A1) => A2, args_1: (args_0: A3) => A4) => <B1>(args_0: Effect<A1, A3, B1>) => Effect<A2, A4, B1>;
export declare const mapLeft: <A1, A2>(args_0: (args_0: A1) => A2) => <B1, B2>(args_0: Effect<A1, B1, B2>) => Effect<A2, B1, B2>;
export declare const mapRight: <A1, A2>(args_0: (args_0: A1) => A2) => <B1, B2>(args_0: Effect<B1, A1, B2>) => Effect<B1, A2, B2>;
export declare const mapErr: <A1, A2>(args_0: (args_0: A1) => A2) => <B1, B2>(args_0: Effect<B1, A1, B2>) => Effect<B1, A2, B2>;
export declare const bitap: <A1, A2>(args_0: (args_0: A1) => void, args_1: (args_0: A2) => void) => <B1>(args_0: Effect<A1, A2, B1>) => Effect<A1, A2, B1>;
export declare const tapLeft: <A1>(args_0: (args_0: A1) => void) => <B1, B2>(args_0: Effect<A1, B1, B2>) => Effect<A1, B1, B2>;
export declare const tapRight: <A1>(args_0: (args_0: A1) => void) => <B1, B2>(args_0: Effect<B1, A1, B2>) => Effect<B1, A1, B2>;
export declare const tapErr: <A1>(args_0: (args_0: A1) => void) => <B1, B2>(args_0: Effect<B1, A1, B2>) => Effect<B1, A1, B2>;
export declare const ap: <A1, A2, A3>(args_0: Effect<A1, A2, A3>) => <B1, B2, B3>(args_0: Effect<(args_0: A1) => B1, B2, B3>) => Effect<B1, A2 | B2, A3 & B3>;
export declare const liftA2: <A1, A2, A3>(args_0: (args_0: A1, args_1: A2) => A3) => <B1, B2>(args_0: Effect<A1, B1, B2>) => <C1, C2>(args_0: Effect<A2, C1, C2>) => Effect<A3, B1 | C1, B2 & C2>;
export declare const product: <A1, A2, A3>(args_0: Effect<A1, A2, A3>) => <B1, B2, B3>(args_0: Effect<B1, B2, B3>) => Effect<[A1, B1], A2 | B2, A3 & B3>;
export declare const productMany: <A1, A2, A3>(args_0: Effect<A1, A2, A3>) => (args_0: Effect<A1, A2, A3>[]) => Effect<A1[], A2, A3>;
export declare const flatMap: <A1, A2, A3, A4>(args_0: (args_0: A1) => Effect<A2, A3, A4>) => <B1, B2>(args_0: Effect<A1, B1, B2>) => Effect<A2, A3 | B1, A4 & B2>;
export declare const andThen: <A1, A2, A3, A4>(args_0: (args_0: A1) => Effect<A2, A3, A4>) => <B1, B2>(args_0: Effect<A1, B1, B2>) => Effect<A2, A3 | B1, A4 & B2>;
export declare const chain: <A1, A2, A3, A4>(args_0: (args_0: A1) => Effect<A2, A3, A4>) => <B1, B2>(args_0: Effect<A1, B1, B2>) => Effect<A2, A3 | B1, A4 & B2>;
export declare const flatten: <A1, A2, A3, A4, A5>(args_0: Effect<Effect<A1, A2, A3>, A4, A5>) => Effect<A1, A2 | A4, A3 & A5>;
export declare const biFlatMap: <A1, A2, A3, A4, A5>(args_0: (args_0: A1) => Effect<A2, A3, A4>, args_1: (args_0: A5) => Effect<A2, A3, A4>) => <B1>(args_0: Effect<A1, A5, B1>) => Effect<A2, A3, A4 & B1>;
export declare const orElse: <A1, A2, A3, A4>(args_0: (args_0: A1) => Effect<A2, A3, A4>) => <B1>(args_0: Effect<A2, A1, B1>) => Effect<A2, A3, A4 & B1>;
export declare const alt: <A1, A2, A3>(args_0: () => Effect<A1, A2, A3>) => <B1, B2>(args_0: Effect<A1, B1, B2>) => Effect<A1, A2, A3>;
export declare const or: <A1, A2, A3>(args_0: Effect<A1, A2, A3>) => <B1, B2>(args_0: Effect<A1, B1, B2>) => Effect<A1, A2 | B1, A3 & B2>;
export declare const pluck: <A, K extends keyof A>(k: K) => <B1, B2>(args_0: Effect<A, B1, B2>) => Effect<A[K], B1, B2>;