import { HKT } from "@tsplus/stdlib/prelude/HKT";
import { Covariant } from "@tsplus/stdlib/prelude/Covariant";
import { IdentityBoth } from "@tsplus/stdlib/prelude/IdentityBoth";
import type { CovariantComposition } from "@tsplus/stdlib/prelude/Covariant";
/**
 * @tsplus type ForEach
 */
export type ForEach<F extends HKT> = {
    readonly Law: {
        readonly ForEach: "ForEach";
    };
    readonly forEachF: ForEach.Fn<F>;
} & Covariant<F>;
/**
 * @tsplus type ForEach/Ops
 */
export interface ForEachOps {
}
export declare const ForEach: ForEachOps;
/**
 * @tsplus type ForEachComposition
 */
export type ForEachComposition<F extends HKT, G extends HKT> = {
    readonly Law: {
        readonly ForEach: "ForEach";
    };
    readonly forEachF: ForEach.CompositionFn<F, G>;
} & CovariantComposition<F, G>;
export declare namespace ForEach {
    interface Fn<F extends HKT> {
        <G extends HKT>(G: IdentityBoth<G> & Covariant<G>): <GR, GE, A, B>(f: (a: A) => HKT.Kind<G, GR, GE, B>) => <FR, FE>(fa: HKT.Kind<F, FR, FE, A>) => HKT.Kind<G, GR, GE, HKT.Kind<F, FR, FE, B>>;
    }
    interface Fn_<F extends HKT> {
        <G extends HKT, FR, FE, A>(fa: HKT.Kind<F, FR, FE, A>, G: IdentityBoth<G> & Covariant<G>): <GK, GQ, GW, GS, GR, GE, B>(f: (a: A) => HKT.Kind<G, GR, GE, B>) => HKT.Kind<G, GR, GE, HKT.Kind<F, FR, FE, B>>;
    }
    interface CompositionFn<F extends HKT, G extends HKT> {
        <H extends HKT>(H: IdentityBoth<H> & Covariant<H>): <HR, HE, A, B>(f: (a: A) => HKT.Kind<H, HR, HE, B>) => <FR, FE, GR, GE>(fa: HKT.Kind<F, FR, FE, HKT.Kind<G, GR, GE, A>>) => HKT.Kind<H, HR, HE, HKT.Kind<F, FR, FE, HKT.Kind<G, GR, GE, B>>>;
    }
}
/**
 * @tsplus static ForEach/Ops implementForEachF
 * @tsplus location "@tsplus/stdlib/prelude/ForEach"
 */
export declare function implementForEachF<F extends HKT>(): (i: <N extends string, R, E, A, B, G extends HKT>(_: {
    A: A;
    B: B;
    G: G;
    N: N;
    R: R;
    E: E;
}) => (G: IdentityBoth<G> & Covariant<G>) => (f: (a: A) => HKT.Kind<G, R, E, B>) => (fa: HKT.Kind<F, R, E, A>) => HKT.Kind<G, R, E, HKT.Kind<F, R, E, B>>) => ForEach.Fn<F>;
/**
 * @tsplus static ForEach/Ops getComposition
 * @tsplus location "@tsplus/stdlib/prelude/ForEach"
 */
export declare function getComposition<F extends HKT, G extends HKT>(F_: ForEach<F>, G_: ForEach<G>): ForEachComposition<F, G>;
/**
 * @tsplus static ForEach/Ops sequenceF
 * @tsplus location "@tsplus/stdlib/prelude/ForEach"
 */
export declare function sequenceF<T extends HKT>(T: ForEach<T>): <F extends import("./HKT").HKT>(App: import("@tsplus/stdlib/prelude/Covariant").Covariant<F> & import("./AssociativeBoth").AssociativeBoth<F> & import("./Any").Any<F>) => <R, E, FR, FE, A>(_: import("./HKT").HKT.Kind<T, R, E, import("./HKT").HKT.Kind<F, FR, FE, A>>) => import("./HKT").HKT.Kind<F, FR, FE, import("./HKT").HKT.Kind<T, R, E, A>>;
//# sourceMappingURL=ForEach.d.ts.map