import type { Covariant, CovariantComposition } from "../Covariant/index.js";
import * as HKT from "../HKT/index.js";
import type { IdentityBoth } from "../IdentityBoth/index.js";
export interface ForeachFn<F extends HKT.URIS, C = HKT.Auto> {
    <G extends HKT.URIS, GC = HKT.Auto>(G: IdentityBoth<G, GC> & Covariant<G, GC>): <GK, GQ, GW, GX, GI, GS, GR, GE, A, B>(f: (a: A) => HKT.Kind<G, GC, GK, GQ, GW, GX, GI, GS, GR, GE, B>) => <FK, FQ, FW, FX, FI, FS, FR, FE>(fa: HKT.Kind<F, C, FK, FQ, FW, FX, FI, FS, FR, FE, A>) => HKT.Kind<G, GC, GK, GQ, GW, GX, GI, GS, GR, GE, HKT.Kind<F, C, FK, FQ, FW, FX, FI, FS, FR, FE, B>>;
}
export interface ForeachFn_<F extends HKT.URIS, C = HKT.Auto> {
    <G extends HKT.URIS, GC, FK, FQ, FW, FX, FI, FS, FR, FE, A>(fa: HKT.Kind<F, C, FK, FQ, FW, FX, FI, FS, FR, FE, A>, G: IdentityBoth<G, GC> & Covariant<G, GC>): <GK, GQ, GW, GX, GI, GS, GR, GE, B>(f: (a: A) => HKT.Kind<G, GC, GK, GQ, GW, GX, GI, GS, GR, GE, B>) => HKT.Kind<G, GC, GK, GQ, GW, GX, GI, GS, GR, GE, HKT.Kind<F, C, FK, FQ, FW, FX, FI, FS, FR, FE, B>>;
}
export interface ForEach<F extends HKT.URIS, C = HKT.Auto> extends HKT.Base<F, C>, Covariant<F, C> {
    readonly _ForEach: "ForEach";
    readonly forEachF: ForeachFn<F, C>;
}
export declare function implementForEachF<F extends HKT.URIS, C = HKT.Auto>(): (i: <N extends string, K, SI, SO, X, I, S, R, E, A, B, G>(_: {
    A: A;
    B: B;
    G: G;
    N: N;
    K: K;
    SI: SI;
    SO: SO;
    X: X;
    I: I;
    S: S;
    R: R;
    E: E;
}) => (G: IdentityBoth<HKT.UHKT<G>> & Covariant<HKT.UHKT<G>>) => (f: (a: A) => HKT.HKT<G, B>) => (fa: HKT.Kind<F, C, K, SI, SO, X, I, S, R, E, A>) => HKT.HKT<G, HKT.Kind<F, C, K, SI, SO, X, I, S, R, E, B>>) => ForeachFn<F, C>;
export interface ForEachCompositionFn<F extends HKT.URIS, G extends HKT.URIS, CF = HKT.Auto, CG = HKT.Auto> {
    <H extends HKT.URIS, CH = HKT.Auto>(H: IdentityBoth<H, CH> & Covariant<H, CH>): <HK, HQ, HW, HX, HI, HS, HR, HE, A, B>(f: (a: A) => HKT.Kind<H, CH, HK, HQ, HW, HX, HI, HS, HR, HE, B>) => <FK, FQ, FW, FX, FI, FS, FR, FE, GK, GQ, GW, GX, GI, GS, GR, GE>(fa: HKT.Kind<F, CF, FK, FQ, FW, FX, FI, FS, FR, FE, HKT.Kind<G, CG, GK, GQ, GW, GX, GI, GS, GR, GE, A>>) => HKT.Kind<H, CH, HK, HQ, HW, HX, HI, HS, HR, HE, HKT.Kind<F, CF, FK, FQ, FW, FX, FI, FS, FR, FE, HKT.Kind<G, CG, GK, GQ, GW, GX, GI, GS, GR, GE, B>>>;
}
export interface ForEachComposition<F extends HKT.URIS, G extends HKT.URIS, CF = HKT.Auto, CG = HKT.Auto> extends HKT.CompositionBase2<F, G, CF, CG>, CovariantComposition<F, G, CF, CG> {
    readonly _ForEachComposition: "ForEachComposition";
    readonly forEachF: ForEachCompositionFn<F, G, CF, CG>;
}
export declare function getForEachComposition<F extends HKT.URIS, G extends HKT.URIS, CF = HKT.Auto, CG = HKT.Auto>(F: ForEach<F, CF>, G: ForEach<G, CG>): ForEachComposition<F, G, CF, CG>;
export declare function sequenceF<T extends HKT.URIS, C>(T: ForEach<T, C>): <F extends HKT.URIS, FC>(App: Covariant<F, FC> & IdentityBoth<F, FC>) => <K, Q, W, X, I, S, R, E, FK, FQ, FW, FX, FI, FS, FR, FE, A>(_: HKT.Kind<T, C, K, Q, W, X, I, S, R, E, HKT.Kind<F, FC, FK, FQ, FW, FX, FI, FS, FR, FE, A>>) => HKT.Kind<F, FC, FK, FQ, FW, FX, FI, FS, FR, FE, HKT.Kind<T, C, K, Q, W, X, I, S, R, E, A>>;
//# sourceMappingURL=index.d.ts.map