/**
 * @typed/fp/FxT is a transformer for creating Do-notation compatible versions of
 * other data types.
 *
 * @since 0.13.0
 */
import { Apply, Apply1, Apply2, Apply3, Apply4 } from 'fp-ts/Apply';
import { Either } from 'fp-ts/Either';
import { FromReader, FromReader2, FromReader3, FromReader3C, FromReader4 } from 'fp-ts/FromReader';
import { HKT, HKT2, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from 'fp-ts/HKT';
import { NaturalTransformation, NaturalTransformation11, NaturalTransformation12, NaturalTransformation12C, NaturalTransformation13, NaturalTransformation13C, NaturalTransformation14, NaturalTransformation14C, NaturalTransformation21, NaturalTransformation22, NaturalTransformation22C, NaturalTransformation23, NaturalTransformation23C, NaturalTransformation23R, NaturalTransformation24, NaturalTransformation24R, NaturalTransformation24S, NaturalTransformation33, NaturalTransformation34 } from 'fp-ts/NaturalTransformation';
import { Pointed, Pointed1, Pointed2, Pointed3, Pointed4 } from 'fp-ts/Pointed';
import { A, U } from 'ts-toolbelt';
import { Arity1 } from './function';
import { Fx } from './Fx';
import { ApplyVariance, Hkt, Initial } from './HKT';
import { MonadRec, MonadRec1, MonadRec2, MonadRec2C, MonadRec3, MonadRec4 } from './MonadRec';
import { ProvideAll, ProvideAll2, ProvideAll3, ProvideAll4, ProvideSome, ProvideSome2, ProvideSome3, ProvideSome4, UseAll, UseAll2, UseAll3, UseAll4, UseSome, UseSome2, UseSome3, UseSome4 } from './Provide';
/**
 * @category Model
 * @since 0.13.0
 */
export declare type FxT<F, Params extends readonly any[]> = Params extends readonly [...infer Init, infer R] ? Fx<Hkt<F, readonly [...Init, unknown]>, R> : never;
/**
 * @category Type-level
 * @since 0.13.0
 */
export declare type LiftFx<F> = F extends URIS ? LiftFx1<F> : F extends URIS2 ? LiftFx2<F> : F extends URIS3 ? LiftFx3<F> : F extends URIS4 ? LiftFx4<F> : LiftFxHKT<F>;
/**
 * @category Type-level
 * @since 0.13.0
 */
export declare type LiftFx1<F extends URIS> = <A>(kind: Kind<F, A>) => Fx<Kind<F, A>, A>;
/**
 * @category Type-level
 * @since 0.13.0
 */
export declare type LiftFx2<F extends URIS2> = <E, A>(kind: Kind2<F, OrUnknown<E>, A>) => Fx<Kind2<F, OrUnknown<E>, A>, A>;
declare type IsNever<T> = A.Equals<[T], [never]> extends 1 ? true : false;
declare type OrUnknown<T> = IsNever<T> extends true ? unknown : T;
/**
 * @category Type-level
 * @since 0.13.0
 */
export declare type LiftFx3<F extends URIS3> = <R, E, A>(kind: Kind3<F, OrUnknown<R>, E, A>) => Fx<Kind3<F, OrUnknown<R>, E, A>, A>;
/**
 * @category Type-level
 * @since 0.13.0
 */
export declare type LiftFx4<F extends URIS4> = <S, R, E, A>(kind: Kind4<F, S, OrUnknown<R>, E, A>) => Fx<Kind4<F, S, OrUnknown<R>, E, A>, A>;
/**
 * @category Type-level
 * @since 0.13.0
 */
export declare type LiftFxHKT<F> = <A>(kind: HKT<F, A>) => Fx<HKT<F, A>, A>;
/**
 * Create a lift function that will convert any F<A> into Fx<F<A>, A>
 * @category Constructor
 * @since 0.13.0
 */
export declare const liftFx: <F>() => LiftFx<F>;
/**
 * @category Lift
 * @since 0.13.0
 */
export declare function getDo<F extends URIS>(): <Y extends Kind<F, any>, R, N = unknown>(f: (lift: LiftFx1<F>) => Generator<Y, R, N>) => Fx<Y, R, N>;
export declare function getDo<F extends URIS2, E = any>(): <Y extends Kind2<F, E, any>, R, N = unknown>(f: (lift: LiftFx2<F>) => Generator<Y, R, N>) => Fx<Y, R, N>;
export declare function getDo<F extends URIS3, R = any, E = any>(): <Y extends Kind3<F, R, E, any>, Z, N = unknown>(f: (lift: LiftFx3<F>) => Generator<Y, Z, N>) => Fx<Y, Z, N>;
export declare function getDo<F extends URIS4, S = any, R = any, E = any>(): <Y extends Kind4<F, S, R, E, any>, Z, N = unknown>(f: (lift: LiftFx4<F>) => Generator<Y, Z, N>) => Fx<Y, Z, N>;
export declare function getDo<F>(): <Y extends HKT<F, any>, R, N = unknown>(f: (lift: LiftFxHKT<F>) => Generator<Y, R, N>) => Fx<Y, R, N>;
declare type Kind2E<F extends URIS2, E> = [E] extends [Kind2<F, infer R, any>] ? R : never;
declare type Kind3E<F extends URIS3, E> = [E] extends [Kind3<F, any, infer R, any>] ? R : never;
declare type Kind3R<F extends URIS3, E> = [E] extends [Kind3<F, infer R, any, any>] ? R : never;
declare type Kind4E<F extends URIS4, E> = [E] extends [Kind4<F, any, any, infer R, any>] ? R : never;
declare type Kind4R<F extends URIS4, E> = [E] extends [Kind4<F, any, infer R, any, any>] ? R : never;
declare type Kind4S<F extends URIS4, E> = [E] extends [Kind4<F, infer R, any, any, any>] ? R : never;
/**
 * @category Interpreter
 * @since 0.13.0
 */
export declare function toMonad<F extends URIS>(M: MonadRec1<F>): <E extends Kind<F, any>, R>(fx: Fx<E, R>) => Kind<F, R>;
export declare function toMonad<F extends URIS2>(M: MonadRec2<F>): <E extends Kind2<F, any, any>, R>(fx: Fx<E, R>) => Kind2<F, ApplyVariance<F, 'E', U.ListOf<Kind2E<F, E>>>, R>;
export declare function toMonad<F extends URIS2, S>(M: MonadRec2C<F, S>): <E extends Kind2<F, S, any>, R>(fx: Fx<E, R>) => Kind2<F, S, R>;
export declare function toMonad<F extends URIS3>(M: MonadRec3<F>): <E extends Kind3<F, any, any, any>, R>(fx: Fx<E, R>) => Kind3<F, ApplyVariance<F, 'R', U.ListOf<Kind3R<F, E>>>, ApplyVariance<F, 'E', U.ListOf<Kind3E<F, E>>>, R>;
export declare function toMonad<F extends URIS4>(M: MonadRec4<F>): <E extends Kind4<F, any, any, any, any>, R>(fx: Fx<E, R>) => Kind4<F, ApplyVariance<F, 'S', U.ListOf<Kind4S<F, E>>>, ApplyVariance<F, 'R', U.ListOf<Kind4R<F, E>>>, ApplyVariance<F, 'E', U.ListOf<Kind4E<F, E>>>, R>;
export declare function toMonad<F>(M: MonadRec<F>): <E, R>(fx: Fx<E, R>) => HKT<F, R>;
/**
 * @category Combinator
 * @since 0.13.0
 */
export declare function map<F extends URIS>(): <A, B>(f: (value: A) => B) => (fx: FxT<F, [A]>) => FxT<F, [B]>;
export declare function map<F extends URIS2>(): <A, B>(f: (value: A) => B) => <E>(fx: FxT<F, [E, A]>) => FxT<F, [E, B]>;
export declare function map<F extends URIS3>(): <A, B>(f: (value: A) => B) => <R, E>(fx: FxT<F, [R, E, A]>) => FxT<F, [R, E, B]>;
export declare function map<F extends URIS4>(): <A, B>(f: (value: A) => B) => <S, R, E>(fx: FxT<F, [S, R, E, A]>) => FxT<F, [S, R, E, B]>;
export declare function map<F>(): <A, B>(f: (value: A) => B) => (fx: FxT<F, [A]>) => FxT<F, [B]>;
/**
 * @category Combinator
 * @since 0.13.0
 */
export declare function chain<F extends URIS>(): <A, B>(f: (value: A) => FxT<F, [B]>) => (fx: FxT<F, [A]>) => FxT<F, [ApplyVariance<F, 'A', [B, A]>]>;
export declare function chain<F extends URIS2>(): <A, E1, B>(f: (value: A) => FxT<F, [E1, B]>) => <E2>(fx: FxT<F, [E2, A]>) => FxT<F, [ApplyVariance<F, 'E', [E1, E2]>, B]>;
export declare function chain<F extends URIS3>(): <A, R1, E1, B>(f: (value: A) => FxT<F, [R1, E1, B]>) => <R2, E2>(fx: FxT<F, [R2, E2, A]>) => FxT<F, [
    ApplyVariance<F, 'R', [R1, R2]>,
    ApplyVariance<F, 'E', [E1, E2]>,
    ApplyVariance<F, 'A', [B, A]>
]>;
export declare function chain<F extends URIS4>(): <A, S1, R1, E1, B>(f: (value: A) => FxT<F, [S1, R1, E1, B]>) => <S2, R2, E2>(fx: FxT<F, [S2, R2, E2, A]>) => FxT<F, [
    ApplyVariance<F, 'S', [S1, S2]>,
    ApplyVariance<F, 'R', [R1, R2]>,
    ApplyVariance<F, 'E', [E1, E2]>,
    ApplyVariance<F, 'A', [B, A]>
]>;
export declare function chain<F>(): <A, B>(f: (value: A) => FxT<F, [B]>) => (fx: FxT<F, [A]>) => FxT<F, [B]>;
/**
 * @category Combinator
 * @since 0.13.0
 */
export declare function ap<F extends URIS>(M: MonadRec1<F> & Apply1<F>): <A>(fa: FxT<F, [A]>) => <B>(fab: FxT<F, [Arity1<A, B>]>) => FxT<F, [B]>;
export declare function ap<F extends URIS2>(M: MonadRec2<F> & Apply2<F>): <E1, A>(fa: FxT<F, [E1, A]>) => <E2, B>(fab: FxT<F, [E2, Arity1<A, B>]>) => FxT<F, [ApplyVariance<F, 'E', [E1, E2]>, B]>;
export declare function ap<F extends URIS2, E>(M: MonadRec2<F> & Apply2<F>): <A>(fa: FxT<F, [E, A]>) => <B>(fab: FxT<F, [E, Arity1<A, B>]>) => FxT<F, [E, B]>;
export declare function ap<F extends URIS3>(M: MonadRec3<F> & Apply3<F>): <R1, E1, A>(fa: FxT<F, [R1, E1, A]>) => <R2, E2, B>(fab: FxT<F, [R2, E2, Arity1<A, B>]>) => FxT<F, [ApplyVariance<F, 'R', [R1, R2]>, ApplyVariance<F, 'E', [E1, E2]>, B]>;
export declare function ap<F extends URIS4>(M: MonadRec4<F> & Apply4<F>): <S1, R1, E1, A>(fa: FxT<F, [S1, R1, E1, A]>) => <S2, R2, E2, B>(fab: FxT<F, [S2, R2, E2, Arity1<A, B>]>) => FxT<F, [
    ApplyVariance<F, 'S', [S1, S2]>,
    ApplyVariance<F, 'R', [R1, R2]>,
    ApplyVariance<F, 'E', [E1, E2]>,
    B
]>;
export declare function ap<F>(M: MonadRec<F> & Apply<F>): <A>(fa: FxT<F, [A]>) => <B>(fab: FxT<F, [Arity1<A, B>]>) => FxT<F, [B]>;
/**
 * @category Combinator
 * @since 0.13.0
 */
export declare function chainRec<F extends URIS>(M: MonadRec1<F>): ChainRecFxT<F>;
export declare function chainRec<F extends URIS2>(M: MonadRec2<F>): ChainRecFxT<F>;
export declare function chainRec<F extends URIS3>(M: MonadRec3<F>): ChainRecFxT<F>;
export declare function chainRec<F extends URIS4>(M: MonadRec4<F>): ChainRecFxT<F>;
/**
 * @category Type-level
 * @since 0.13.0
 */
export declare type ChainRecFxT<F> = F extends URIS2 ? <A, E, B>(f: Arity1<A, FxT<F, [E, Either<A, B>]>>) => (a: A) => FxT<F, [E, B]> : F extends URIS3 ? <A, R, E, B>(f: Arity1<A, FxT<F, [R, E, Either<A, B>]>>) => (a: A) => FxT<F, [R, E, B]> : F extends URIS4 ? <A, S, R, E, B>(f: Arity1<A, FxT<F, [S, R, E, Either<A, B>]>>) => (a: A) => FxT<F, [S, R, E, B]> : <A, B>(f: Arity1<A, FxT<F, [Either<A, B>]>>) => (a: A) => FxT<F, [B]>;
/**
 * @category Constructor
 * @since 0.13.0
 */
export declare function of<F extends URIS>(M: Pointed1<F>): <A>(value: A) => Fx<Hkt<F, [A]>, A>;
export declare function of<F extends URIS2>(M: Pointed2<F>): <A, E = Initial<F, 'E'>>(value: A) => Fx<Hkt<F, [E, A]>, A>;
export declare function of<F extends URIS3>(M: Pointed3<F>): <A, R = Initial<F, 'R'>, E = Initial<F, 'E'>>(value: A) => Fx<Hkt<F, [R, E, A]>, A>;
export declare function of<F extends URIS4>(M: Pointed4<F>): <A, S = Initial<F, 'S'>, R = Initial<F, 'R'>, E = Initial<F, 'E'>>(value: A) => Fx<Hkt<F, [S, R, E, A]>, A>;
export declare function of<F>(M: Pointed<F>): <A>(value: A) => Fx<HKT<F, A>, A>;
/**
 * @category Constructor
 * @since 0.13.0
 */
export declare function ask<F extends URIS2>(M: FromReader2<F>): <A>() => Fx<Hkt<F, [A, A]>, A>;
export declare function ask<F extends URIS3>(M: FromReader3<F>): <A>() => Fx<Hkt<F, [A, Initial<F, 'E'>, A]>, A>;
export declare function ask<F extends URIS3, E>(M: FromReader3C<F, E>): <A>() => Fx<Hkt<F, [A, E, A]>, A>;
export declare function ask<F extends URIS4>(M: FromReader4<F>): <A>() => Fx<Hkt<F, [Initial<F, 'S'>, A, Initial<F, 'E'>, A]>, A>;
export declare function ask<F>(M: FromReader<F>): <A>() => Fx<HKT2<F, A, A>, A>;
/**
 * @category Combinator
 * @since 0.13.0
 */
export declare function useSome<F extends URIS2>(M: UseSome2<F> & MonadRec2<F>): <A>(provided: A) => <B, T>(fx: Fx<Hkt<F, [A & B, unknown]>, T>) => Fx<Hkt<F, [B, unknown]>, T>;
export declare function useSome<F extends URIS3>(M: UseSome3<F> & MonadRec3<F>): <A>(provided: A) => <B, E, T>(fx: Fx<Hkt<F, [A & B, E, unknown]>, T>) => Fx<Hkt<F, [B, E, unknown]>, T>;
export declare function useSome<F extends URIS4>(M: UseSome4<F> & MonadRec4<F>): <A>(provided: A) => <B, S, E, T>(fx: Fx<Hkt<F, [S, A & B, E, unknown]>, T>) => Fx<Hkt<F, [S, B, E, unknown]>, T>;
export declare function useSome<F>(M: UseSome<F> & MonadRec<F>): <A>(provided: A) => <B, T>(fx: Fx<HKT2<F, A & B, unknown>, T>) => Fx<HKT2<F, B, unknown>, T>;
/**
 * @category Combinator
 * @since 0.13.0
 */
export declare function provideSome<F extends URIS2>(M: ProvideSome2<F> & MonadRec2<F>): <A>(provided: A) => <B, T>(fx: Fx<Hkt<F, [A & B, unknown]>, T>) => Fx<Hkt<F, [B, unknown]>, T>;
export declare function provideSome<F extends URIS3>(M: ProvideSome3<F> & MonadRec3<F>): <A>(provided: A) => <B, E, T>(fx: Fx<Hkt<F, [A & B, E, unknown]>, T>) => Fx<Hkt<F, [B, E, unknown]>, T>;
export declare function provideSome<F extends URIS4>(M: ProvideSome4<F> & MonadRec4<F>): <A>(provided: A) => <B, S, E, T>(fx: Fx<Hkt<F, [S, A & B, E, unknown]>, T>) => Fx<Hkt<F, [S, B, E, unknown]>, T>;
export declare function provideSome<F>(M: ProvideSome<F> & MonadRec<F>): <A>(provided: A) => <B, T>(fx: Fx<HKT2<F, A & B, unknown>, T>) => Fx<HKT2<F, B, unknown>, T>;
/**
 * @category Combinator
 * @since 0.13.0
 */
export declare function useAll<F extends URIS2>(M: UseAll2<F> & MonadRec2<F>): <A>(provided: A) => <T>(fx: Fx<Hkt<F, [A, unknown]>, T>) => Fx<Hkt<F, [unknown, unknown]>, T>;
export declare function useAll<F extends URIS3>(M: UseAll3<F> & MonadRec3<F>): <A>(provided: A) => <E, T>(fx: Fx<Hkt<F, [A, E, unknown]>, T>) => Fx<Hkt<F, [unknown, E, unknown]>, T>;
export declare function useAll<F extends URIS4>(M: UseAll4<F> & MonadRec4<F>): <A>(provided: A) => <S, E, T>(fx: Fx<Hkt<F, [S, A, E, unknown]>, T>) => Fx<Hkt<F, [S, unknown, E, unknown]>, T>;
export declare function useAll<F>(M: UseAll<F> & MonadRec<F>): <A>(provided: A) => <T>(fx: Fx<HKT2<F, A, unknown>, T>) => Fx<HKT2<F, unknown, unknown>, T>;
/**
 * @category Combinator
 * @since 0.13.0
 */
export declare function provideAll<F extends URIS2>(M: ProvideAll2<F> & MonadRec2<F>): <A>(provided: A) => <T>(fx: Fx<Hkt<F, [A, unknown]>, T>) => Fx<Hkt<F, [unknown, unknown]>, T>;
export declare function provideAll<F extends URIS3>(M: ProvideAll3<F> & MonadRec3<F>): <A>(provided: A) => <E, T>(fx: Fx<Hkt<F, [A, E, unknown]>, T>) => Fx<Hkt<F, [unknown, E, unknown]>, T>;
export declare function provideAll<F extends URIS4>(M: ProvideAll4<F> & MonadRec4<F>): <A>(provided: A) => <S, E, T>(fx: Fx<Hkt<F, [S, A, E, unknown]>, T>) => Fx<Hkt<F, [S, unknown, E, unknown]>, T>;
export declare function provideAll<F>(M: ProvideAll<F> & MonadRec<F>): <A>(provided: A) => <T>(fx: Fx<HKT2<F, A, unknown>, T>) => Fx<HKT2<F, unknown, unknown>, T>;
/**
 * @category Natural Transformation
 * @since 0.13.0
 */
export declare function fromNaturalTransformation<F extends URIS, G extends URIS>(transformation: NaturalTransformation11<F, G>): <A>(fa: Kind<F, A>) => Fx<Kind<G, A>, A>;
export declare function fromNaturalTransformation<F extends URIS, G extends URIS2>(transformation: NaturalTransformation12<F, G>): <A, E = Initial<G, 'E'>>(fa: Kind<F, A>) => Fx<Kind2<G, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS, G extends URIS2, E>(transformation: NaturalTransformation12C<F, G, E>): <A>(fa: Kind<F, A>) => Fx<Kind2<G, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS, G extends URIS3>(transformation: NaturalTransformation13<F, G>): <A, R = Initial<G, 'R'>, E = Initial<G, 'E'>>(fa: Kind<F, A>) => Fx<Kind3<G, R, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS, G extends URIS3, E>(transformation: NaturalTransformation13C<F, G, E>): <A, R = Initial<G, 'R'>>(fa: Kind<F, A>) => Fx<Kind3<G, R, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS, G extends URIS4>(transformation: NaturalTransformation14<F, G>): <A, S = Initial<G, 'S'>, R = Initial<G, 'R'>, E = Initial<G, 'E'>>(fa: Kind<F, A>) => Fx<Kind4<G, S, R, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS, G extends URIS4, E>(transformation: NaturalTransformation14C<F, G, E>): <A, S = Initial<G, 'S'>, R = Initial<G, 'R'>>(fa: Kind<F, A>) => Fx<Kind4<G, S, R, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS2, G extends URIS>(transformation: NaturalTransformation21<F, G>): <E, A>(fa: Kind2<F, E, A>) => Fx<Kind<G, A>, A>;
export declare function fromNaturalTransformation<F extends URIS2, G extends URIS2>(transformation: NaturalTransformation22<F, G>): <E, A>(fa: Kind2<F, E, A>) => Fx<Kind2<G, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS2, G extends URIS2, E>(transformation: NaturalTransformation22C<F, G, E>): <A>(fa: Kind2<F, E, A>) => Fx<Kind2<G, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS2, G extends URIS3>(transformation: NaturalTransformation23<F, G> | NaturalTransformation23R<F, G>): <E, A, R = Initial<G, 'R'>>(fa: Kind2<F, E, A>) => Fx<Kind3<G, R, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS2, G extends URIS3, E>(transformation: NaturalTransformation23C<F, G, E>): <A, R = Initial<G, 'R'>>(fa: Kind2<F, E, A>) => Fx<Kind3<G, R, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS2, G extends URIS4>(transformation: NaturalTransformation24<F, G> | NaturalTransformation24R<F, G> | NaturalTransformation24S<F, G>): <E, A, S = Initial<G, 'S'>, R = Initial<G, 'R'>>(fa: Kind2<F, E, A>) => Fx<Kind4<G, S, R, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS3, G extends URIS3>(transformation: NaturalTransformation33<F, G>): <R, E, A>(fa: Kind3<F, R, E, A>) => Fx<Kind3<G, R, E, A>, A>;
export declare function fromNaturalTransformation<F extends URIS3, G extends URIS4>(transformation: NaturalTransformation34<F, G>): <R, E, A, S = Initial<G, 'S'>>(fa: Kind3<F, R, E, A>) => Fx<Kind4<G, S, R, E, A>, A>;
export declare function fromNaturalTransformation<F, G>(transformation: NaturalTransformation<F, G>): <A>(fa: HKT<F, A>) => Fx<HKT<G, A>, A>;
export {};
//# sourceMappingURL=FxT.d.ts.map