/**
 * @since 0.1.0
 */
import { Applicative3 } from 'fp-ts/lib/Applicative'
import { Apply3 } from 'fp-ts/lib/Apply'
import { Either } from 'fp-ts/lib/Either'
import { Predicate, Refinement } from 'fp-ts/lib/function'
import { Functor3 } from 'fp-ts/lib/Functor'
import { IO } from 'fp-ts/lib/IO'
import { IOEither } from 'fp-ts/lib/IOEither'
import { Monad3 } from 'fp-ts/lib/Monad'
import { MonadThrow3 } from 'fp-ts/lib/MonadThrow'
import { Option } from 'fp-ts/lib/Option'
import { State } from 'fp-ts/lib/State'
import { Task } from 'fp-ts/lib/Task'
import * as TE from 'fp-ts/lib/TaskEither'
import TaskEither = TE.TaskEither
/**
 * @category model
 * @since 0.1.0
 */
export interface StateTaskEither<S, E, A> {
  (s: S): TaskEither<E, [A, S]>
}
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const get: <S>() => StateTaskEither<S, never, S>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const put: <S>(s: S) => StateTaskEither<S, never, void>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const modify: <S>(f: (s: S) => S) => StateTaskEither<S, never, void>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const gets: <S, A>(f: (s: S) => A) => StateTaskEither<S, never, A>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const left: <S, E>(e: E) => StateTaskEither<S, E, never>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const right: <S, A>(a: A) => StateTaskEither<S, never, A>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const leftIO: <S, E>(me: IO<E>) => StateTaskEither<S, E, never>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const rightIO: <S, A>(ma: IO<A>) => StateTaskEither<S, never, A>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const leftTask: <S, E>(me: Task<E>) => StateTaskEither<S, E, never>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const rightTask: <S, A>(ma: Task<A>) => StateTaskEither<S, never, A>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const leftState: <S, E>(me: State<S, E>) => StateTaskEither<S, E, never>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const rightState: <S, A>(ma: State<S, A>) => StateTaskEither<S, never, A>
/**
 * @category constructors
 * @since 0.1.18
 */
export declare const fromOption: <E>(onNone: () => E) => <R, A>(ma: Option<A>) => StateTaskEither<R, E, A>
/**
 * @category constructors
 * @since 0.1.18
 */
export declare const fromEither: <R, E, A>(ma: Either<E, A>) => StateTaskEither<R, E, A>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const fromIOEither: <S, E, A>(ma: IOEither<E, A>) => StateTaskEither<S, E, A>
/**
 * @category constructors
 * @since 0.1.0
 */
export declare const fromTaskEither: <S, E, A>(ma: TaskEither<E, A>) => StateTaskEither<S, E, A>
/**
 * @category constructors
 * @since 0.1.10
 */
export declare const fromEitherK: <E, A extends Array<unknown>, B>(
  f: (...a: A) => Either<E, B>
) => <S>(...a: A) => StateTaskEither<S, E, B>
/**
 * @category constructors
 * @since 0.1.10
 */
export declare const fromIOEitherK: <E, A extends Array<unknown>, B>(
  f: (...a: A) => IOEither<E, B>
) => <S>(...a: A) => StateTaskEither<S, E, B>
/**
 * @category constructors
 * @since 0.1.10
 */
export declare const fromTaskEitherK: <E, A extends Array<unknown>, B>(
  f: (...a: A) => TaskEither<E, B>
) => <S>(...a: A) => StateTaskEither<S, E, B>
/**
 * @category constructors
 * @since 0.1.18
 */
export declare const fromPredicate: {
  <E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): <R>(a: A) => StateTaskEither<R, E, B>
  <E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): <R>(a: A) => StateTaskEither<R, E, A>
}
/**
 * @category combinators
 * @since 0.1.18
 */
export declare const filterOrElse: {
  <E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): <R>(
    ma: StateTaskEither<R, E, A>
  ) => StateTaskEither<R, E, B>
  <E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): <R>(ma: StateTaskEither<R, E, A>) => StateTaskEither<R, E, A>
}
/**
 * @category Functor
 * @since 0.1.18
 */
export declare const map: <A, B>(f: (a: A) => B) => <R, E>(fa: StateTaskEither<R, E, A>) => StateTaskEither<R, E, B>
/**
 * @category Apply
 * @since 0.1.18
 */
export declare const ap: <R, E, A>(
  fa: StateTaskEither<R, E, A>
) => <B>(fab: StateTaskEither<R, E, (a: A) => B>) => StateTaskEither<R, E, B>
/**
 * @category Apply
 * @since 0.1.18
 */
export declare const apFirst: <R, E, B>(
  fb: StateTaskEither<R, E, B>
) => <A>(fa: StateTaskEither<R, E, A>) => StateTaskEither<R, E, A>
/**
 * @category Apply
 * @since 0.1.18
 */
export declare const apSecond: <R, E, B>(
  fb: StateTaskEither<R, E, B>
) => <A>(fa: StateTaskEither<R, E, A>) => StateTaskEither<R, E, B>
/**
 * @category Applicative
 * @since 0.1.18
 */
export declare const of: <R, E, A>(a: A) => StateTaskEither<R, E, A>
/**
 * @category Monad
 * @since 0.1.18
 */
export declare const chain: <R, E, A, B>(
  f: (a: A) => StateTaskEither<R, E, B>
) => (ma: StateTaskEither<R, E, A>) => StateTaskEither<R, E, B>
/**
 * @category Monad
 * @since 0.1.18
 */
export declare const chainFirst: <R, E, A, B>(
  f: (a: A) => StateTaskEither<R, E, B>
) => (ma: StateTaskEither<R, E, A>) => StateTaskEither<R, E, A>
/**
 * @category Monad
 * @since 0.1.10
 */
export declare const chainEitherK: <E, A, B>(
  f: (a: A) => Either<E, B>
) => <S>(ma: StateTaskEither<S, E, A>) => StateTaskEither<S, E, B>
/**
 * @category Monad
 * @since 0.1.10
 */
export declare const chainIOEitherK: <E, A, B>(
  f: (a: A) => IOEither<E, B>
) => <S>(ma: StateTaskEither<S, E, A>) => StateTaskEither<S, E, B>
/**
 * @category Monad
 * @since 0.1.10
 */
export declare const chainTaskEitherK: <E, A, B>(
  f: (a: A) => TE.TaskEither<E, B>
) => <S>(ma: StateTaskEither<S, E, A>) => StateTaskEither<S, E, B>
/**
 * @category Monad
 * @since 0.1.18
 */
export declare const flatten: <R, E, A>(
  mma: StateTaskEither<R, E, StateTaskEither<R, E, A>>
) => StateTaskEither<R, E, A>
/**
 * @category instances
 * @since 0.1.0
 */
export declare const URI = 'StateTaskEither'
/**
 * @category instances
 * @since 0.1.0
 */
export declare type URI = typeof URI
declare module 'fp-ts/lib/HKT' {
  interface URItoKind3<R, E, A> {
    StateTaskEither: StateTaskEither<R, E, A>
  }
}
/**
 * @category instances
 * @since 0.1.18
 */
export declare const Functor: Functor3<URI>
/**
 * @category instances
 * @since 0.1.18
 */
export declare const Applicative: Applicative3<URI>
/**
 * @category instances
 * @since 0.1.18
 */
export declare const Apply: Apply3<URI>
/**
 * @category instances
 * @since 0.1.18
 */
export declare const Monad: Monad3<URI>
/**
 * @category instances
 * @since 0.1.0
 */
export declare const stateTaskEither: Monad3<URI> & MonadThrow3<URI>
/**
 * Like `stateTaskEither` but `ap` is sequential
 *
 * @category instances
 * @since 0.1.0
 */
export declare const stateTaskEitherSeq: typeof stateTaskEither
/**
 * @since 0.1.0
 */
export declare const evalState: <S, E, A>(ma: StateTaskEither<S, E, A>, s: S) => TaskEither<E, A>
/**
 * @since 0.1.0
 */
export declare const execState: <S, E, A>(ma: StateTaskEither<S, E, A>, s: S) => TaskEither<E, S>
/**
 * @since 0.1.0
 */
export declare const run: <S, E, A>(ma: StateTaskEither<S, E, A>, s: S) => Promise<Either<E, [A, S]>>