import type { ApFn, ApFn_ } from './Apply';
import type { Functor2, FunctorMin } from './Functor';
import type { Semimonoidal, SemimonoidalMin } from './Semimonoidal';
import type { EnforceNonEmptyRecord } from './util/types';
import { Functor } from './Functor';
import * as HKT from './HKT';
export interface SemimonoidalFunctor<F extends HKT.URIS, C = HKT.Auto> extends Functor<F, C>, Semimonoidal<F, C> {
    readonly crossWith_: CrossWithFn_<F, C>;
    readonly crossWith: CrossWithFn<F, C>;
}
export declare type SemimonoidalFunctorMin<F extends HKT.URIS, C = HKT.Auto> = (SemimonoidalMin<F, C> & FunctorMin<F, C>) | ({
    readonly crossWith_: CrossWithFn_<F, C>;
} & FunctorMin<F, C>) | ({
    readonly crossWith_: CrossWithFn_<F, C>;
} & SemimonoidalMin<F, C> & FunctorMin<F, C>);
export declare function SemimonoidalFunctor<F extends HKT.URIS, C = HKT.Auto>(F: SemimonoidalFunctorMin<F, C>): SemimonoidalFunctor<F, C>;
export interface SemimonoidalFunctor2<F extends HKT.URIS, G extends HKT.URIS, CF = HKT.Auto, CG = HKT.Auto> extends Functor2<F, G, CF, CG> {
    readonly crossWith_: CrossWithFn2_<F, G, CF, CG>;
    readonly crossWith: CrossWithFn2<F, G, CF, CG>;
}
export declare function getSemimonoidalFunctorComposition<F extends HKT.URIS, G extends HKT.URIS, CF = HKT.Auto, CG = HKT.Auto>(F: SemimonoidalFunctor<F, CF>, G: SemimonoidalFunctor<G, CG>): SemimonoidalFunctor2<F, G, CF, CG>;
export interface CrossWithFn_<F extends HKT.URIS, TC = HKT.Auto> {
    <N extends string, K, Q, W, X, I, S, R, E, A, N1 extends string, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(fa: HKT.Kind<F, TC, N, K, Q, W, X, I, S, R, E, A>, fb: HKT.Kind<F, TC, HKT.Intro<TC, 'N', N, N1>, HKT.Intro<TC, 'K', K, K1>, HKT.Intro<TC, 'Q', Q, Q1>, HKT.Intro<TC, 'W', W, W1>, HKT.Intro<TC, 'X', X, X1>, HKT.Intro<TC, 'I', I, I1>, HKT.Intro<TC, 'S', S, S1>, HKT.Intro<TC, 'R', R, R1>, HKT.Intro<TC, 'E', E, E1>, B>, f: (a: A, b: B) => C): HKT.Kind<F, TC, HKT.Mix<TC, 'N', [N, N1]>, HKT.Mix<TC, 'K', [K, K1]>, HKT.Mix<TC, 'Q', [Q, Q1]>, HKT.Mix<TC, 'W', [W, W1]>, HKT.Mix<TC, 'X', [X, X1]>, HKT.Mix<TC, 'I', [I1, I1]>, HKT.Mix<TC, 'S', [S, S1]>, HKT.Mix<TC, 'R', [R, R1]>, HKT.Mix<TC, 'E', [E, E1]>, C>;
}
export interface CrossWithFn<F extends HKT.URIS, TC = HKT.Auto> {
    <A, N1 extends string, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(fb: HKT.Kind<F, TC, N1, K1, Q1, W1, X1, I1, S1, R1, E1, B>, f: (a: A, b: B) => C): <N extends string, K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, TC, HKT.Intro<TC, 'N', N1, N>, HKT.Intro<TC, 'K', K1, K>, HKT.Intro<TC, 'Q', Q1, Q>, HKT.Intro<TC, 'W', W1, W>, HKT.Intro<TC, 'X', X1, X>, HKT.Intro<TC, 'I', I1, I>, HKT.Intro<TC, 'S', S1, S>, HKT.Intro<TC, 'R', R1, R>, HKT.Intro<TC, 'E', E1, E>, A>) => HKT.Kind<F, TC, HKT.Mix<TC, 'N', [N1, N]>, HKT.Mix<TC, 'K', [K1, K]>, HKT.Mix<TC, 'Q', [Q1, Q]>, HKT.Mix<TC, 'W', [W1, W]>, HKT.Mix<TC, 'X', [X1, X]>, HKT.Mix<TC, 'I', [I1, I]>, HKT.Mix<TC, 'S', [S1, S]>, HKT.Mix<TC, 'R', [R1, R]>, HKT.Mix<TC, 'E', [E1, E]>, C>;
}
export interface CrossWithFn2_<F extends HKT.URIS, G extends HKT.URIS, TCF = HKT.Auto, TCG = HKT.Auto> {
    <NF extends string, KF, QF, WF, XF, IF, SF, RF, EF, NG extends string, KG, QG, WG, XG, IG, SG, RG, EG, NF1 extends string, KF1, QF1, WF1, XF1, IF1, SF1, RF1, EF1, NG1 extends string, KG1, QG1, WG1, XG1, IG1, SG1, RG1, EG1, A, B, C>(fga: HKT.Kind<F, TCF, NF, KF, QF, WF, XF, IF, SF, RF, EF, HKT.Kind<G, TCG, NG, KG, QG, WG, XG, IG, SG, RG, EG, A>>, fgb: HKT.Kind<F, TCF, HKT.Intro<TCF, 'N', NF, NF1>, HKT.Intro<TCF, 'K', KF, KF1>, HKT.Intro<TCF, 'Q', QF, QF1>, HKT.Intro<TCF, 'W', WF, WF1>, HKT.Intro<TCF, 'X', XF, XF1>, HKT.Intro<TCF, 'I', IF, IF1>, HKT.Intro<TCF, 'S', SF, SF1>, HKT.Intro<TCF, 'R', RF, RF1>, HKT.Intro<TCF, 'E', EF, EF1>, HKT.Kind<G, TCG, HKT.Intro<TCG, 'N', NG, NG1>, HKT.Intro<TCG, 'K', KG, KG1>, HKT.Intro<TCG, 'Q', QG, QG1>, HKT.Intro<TCG, 'W', WG, WG1>, HKT.Intro<TCG, 'X', XG, XG1>, HKT.Intro<TCG, 'I', IG, IG1>, HKT.Intro<TCG, 'S', SG, SG1>, HKT.Intro<TCG, 'R', RG, RG1>, HKT.Intro<TCG, 'E', EG, EG1>, B>>, f: (a: A, b: B) => C): HKT.Kind<F, TCF, HKT.Mix<TCF, 'N', [NF, NF1]>, HKT.Mix<TCF, 'K', [KF, KF1]>, HKT.Mix<TCF, 'Q', [QF, QF1]>, HKT.Mix<TCF, 'W', [WF, WF1]>, HKT.Mix<TCF, 'X', [XF, XF1]>, HKT.Mix<TCF, 'I', [IF, IF1]>, HKT.Mix<TCF, 'S', [SF, SF1]>, HKT.Mix<TCF, 'R', [RF, RF1]>, HKT.Mix<TCF, 'E', [EF, EF1]>, HKT.Kind<G, TCG, HKT.Mix<TCG, 'N', [NG, NG1]>, HKT.Mix<TCG, 'K', [KG, KG1]>, HKT.Mix<TCG, 'Q', [QG, QG1]>, HKT.Mix<TCG, 'W', [WG, WG1]>, HKT.Mix<TCG, 'X', [XG, XG1]>, HKT.Mix<TCG, 'I', [IG, IG1]>, HKT.Mix<TCG, 'S', [SG, SG1]>, HKT.Mix<TCG, 'R', [RG, RG1]>, HKT.Mix<TCG, 'E', [EG, EG1]>, C>>;
}
export interface CrossWithFn2<F extends HKT.URIS, G extends HKT.URIS, TCF = HKT.Auto, TCG = HKT.Auto> {
    <A, NF1 extends string, KF1, QF1, WF1, XF1, IF1, SF1, RF1, EF1, NG1 extends string, KG1, QG1, WG1, XG1, IG1, SG1, RG1, EG1, B, C>(fgb: HKT.Kind<F, TCF, NF1, KF1, QF1, WF1, XF1, IF1, SF1, RF1, EF1, HKT.Kind<G, TCG, NG1, KG1, QG1, WG1, XG1, IG1, SG1, RG1, EG1, B>>, f: (a: A, b: B) => C): <NF extends string, KF, QF, WF, XF, IF, SF, RF, EF, NG extends string, KG, QG, WG, XG, IG, SG, RG, EG>(fga: HKT.Kind<F, TCF, HKT.Intro<TCF, 'N', NF1, NF>, HKT.Intro<TCF, 'K', KF1, KF>, HKT.Intro<TCF, 'Q', QF1, QF>, HKT.Intro<TCF, 'W', WF1, WF>, HKT.Intro<TCF, 'X', XF1, XF>, HKT.Intro<TCF, 'I', IF1, IF>, HKT.Intro<TCF, 'S', SF1, SF>, HKT.Intro<TCF, 'R', RF1, RF>, HKT.Intro<TCF, 'E', EF1, EF>, HKT.Kind<G, TCG, HKT.Intro<TCG, 'N', NG1, NG>, HKT.Intro<TCG, 'K', KG1, KG>, HKT.Intro<TCG, 'Q', QG1, QG>, HKT.Intro<TCG, 'W', WG1, WG>, HKT.Intro<TCG, 'X', XG1, XG>, HKT.Intro<TCG, 'I', IG1, IG>, HKT.Intro<TCG, 'S', SG1, SG>, HKT.Intro<TCG, 'R', RG1, RG>, HKT.Intro<TCG, 'E', EG1, EG>, A>>) => HKT.Kind<F, TCF, HKT.Mix<TCF, 'N', [NF1, NF]>, HKT.Mix<TCF, 'K', [KF1, KF]>, HKT.Mix<TCF, 'Q', [QF1, QF]>, HKT.Mix<TCF, 'W', [WF1, WF]>, HKT.Mix<TCF, 'X', [XF1, XF]>, HKT.Mix<TCF, 'I', [IF1, IF]>, HKT.Mix<TCF, 'S', [SF1, SF]>, HKT.Mix<TCF, 'R', [RF1, RF]>, HKT.Mix<TCF, 'E', [EF1, EF]>, HKT.Kind<G, TCG, HKT.Mix<TCG, 'N', [NG1, NG]>, HKT.Mix<TCG, 'K', [KG1, KG]>, HKT.Mix<TCG, 'Q', [QG1, QG]>, HKT.Mix<TCG, 'W', [WG1, WG]>, HKT.Mix<TCG, 'X', [XG1, XG]>, HKT.Mix<TCG, 'I', [IG1, IG]>, HKT.Mix<TCG, 'S', [SG1, SG]>, HKT.Mix<TCG, 'R', [RG1, RG]>, HKT.Mix<TCG, 'E', [EG1, EG]>, C>>;
}
export declare function apF_<F extends HKT.URIS, C = HKT.Auto>(A: SemimonoidalFunctor<F, C>): ApFn_<F, C>;
export declare function apF<F extends HKT.URIS, C = HKT.Auto>(A: SemimonoidalFunctor<F, C>): ApFn<F, C>;
export interface CrossSFn<F extends HKT.URIS, C = HKT.Auto> {
    <BN extends string, N1 extends string, K1, Q1, W1, X1, I1, S1, R1, E1, A1, A>(name: Exclude<BN, keyof A>, fb: HKT.Kind<F, C, N1, K1, Q1, W1, X1, I1, S1, R1, E1, A1>): <N extends string, K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, HKT.Intro<C, 'N', N1, N>, HKT.Intro<C, 'K', K1, K>, HKT.Intro<C, 'Q', Q1, Q>, HKT.Intro<C, 'W', W1, W>, HKT.Intro<C, 'X', X1, X>, HKT.Intro<C, 'I', I1, I>, HKT.Intro<C, 'S', S1, S>, HKT.Intro<C, 'R', R1, R>, HKT.Intro<C, 'E', E1, E>, A>) => HKT.Kind<F, C, HKT.Mix<C, 'N', [N, N1]>, HKT.Mix<C, 'K', [K, K1]>, HKT.Mix<C, 'Q', [Q, Q1]>, HKT.Mix<C, 'W', [W, W1]>, HKT.Mix<C, 'X', [X, X1]>, HKT.Mix<C, 'I', [I, I1]>, HKT.Mix<C, 'S', [S, S1]>, HKT.Mix<C, 'R', [R, R1]>, HKT.Mix<C, 'E', [E, E1]>, {
        [K in keyof A | BN]: K extends keyof A ? A[K] : A1;
    }>;
}
export declare function crossSF<F extends HKT.URIS, C = HKT.Auto>(F: SemimonoidalFunctor<F, C>): CrossSFn<F, C>;
export interface CrossTFn<F extends HKT.URIS, C = HKT.Auto> {
    <N1 extends string, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fb: HKT.Kind<F, C, N1, K1, Q1, W1, X1, I1, S1, R1, E1, A1>): <N extends string, K, Q, W, X, I, S, R, E, A extends ReadonlyArray<unknown>>(fas: HKT.Kind<F, C, HKT.Intro<C, 'N', N1, N>, HKT.Intro<C, 'K', K1, K>, HKT.Intro<C, 'Q', Q1, Q>, HKT.Intro<C, 'W', W1, W>, HKT.Intro<C, 'X', X1, X>, HKT.Intro<C, 'I', I1, I>, HKT.Intro<C, 'S', S1, S>, HKT.Intro<C, 'R', R1, R>, HKT.Intro<C, 'E', E1, E>, A>) => HKT.Kind<F, C, HKT.Mix<C, 'N', [N, N1]>, HKT.Mix<C, 'K', [K, K1]>, HKT.Mix<C, 'Q', [Q, Q1]>, HKT.Mix<C, 'W', [W, W1]>, HKT.Mix<C, 'X', [X, X1]>, HKT.Mix<C, 'I', [I, I1]>, HKT.Mix<C, 'S', [S, S1]>, HKT.Mix<C, 'R', [R, R1]>, HKT.Mix<C, 'E', [E, E1]>, readonly [...A, A1]>;
}
export declare function crossTF<F extends HKT.URIS, C = HKT.Auto>(F: SemimonoidalFunctor<F, C>): CrossTFn<F, C>;
export interface LiftA2Fn<F extends HKT.URIS, TC = HKT.Auto> {
    <A, B, D>(f: (a: A) => (b: B) => D): <N extends string, K, Q, W, X, I, S, R, E, N1 extends string, K1, Q1, W1, X1, I1, S1, R1, E1>(fa: HKT.Kind<F, TC, N, K, Q, W, X, I, S, R, E, A>) => (fb: HKT.Kind<F, TC, HKT.Intro<TC, 'N', N, N1>, HKT.Intro<TC, 'K', K, K1>, HKT.Intro<TC, 'Q', Q, Q1>, HKT.Intro<TC, 'W', W, W1>, HKT.Intro<TC, 'X', X, X1>, HKT.Intro<TC, 'I', I, I1>, HKT.Intro<TC, 'S', S, S1>, HKT.Intro<TC, 'R', R, R1>, HKT.Intro<TC, 'E', E, E1>, B>) => HKT.Kind<F, TC, HKT.Mix<TC, 'N', [N, N1]>, HKT.Mix<TC, 'K', [K, K1]>, HKT.Mix<TC, 'Q', [Q, Q1]>, HKT.Mix<TC, 'W', [W, W1]>, HKT.Mix<TC, 'X', [X, X1]>, HKT.Mix<TC, 'I', [I, I1]>, HKT.Mix<TC, 'S', [S, S1]>, HKT.Mix<TC, 'R', [R, R1]>, HKT.Mix<TC, 'E', [E, E1]>, D>;
}
export declare function liftA2F<F extends HKT.URIS, C = HKT.Auto>(F: SemimonoidalFunctor<F, C>): LiftA2Fn<F, C>;
export interface MapNFn<F extends HKT.URIS, TC = HKT.Auto> {
    <KT extends readonly [
        HKT.Kind<F, TC, HKT.Intro<TC, 'N', N, any>, HKT.Intro<TC, 'K', K, any>, HKT.Intro<TC, 'Q', Q, any>, HKT.Intro<TC, 'W', W, any>, HKT.Intro<TC, 'X', X, any>, HKT.Intro<TC, 'I', I, any>, HKT.Intro<TC, 'S', S, any>, HKT.Intro<TC, 'R', R, any>, HKT.Intro<TC, 'E', E, any>, unknown>,
        ...ReadonlyArray<HKT.Kind<F, TC, HKT.Intro<TC, 'N', N, any>, HKT.Intro<TC, 'K', K, any>, HKT.Intro<TC, 'Q', Q, any>, HKT.Intro<TC, 'W', W, any>, HKT.Intro<TC, 'X', X, any>, HKT.Intro<TC, 'I', I, any>, HKT.Intro<TC, 'S', S, any>, HKT.Intro<TC, 'R', R, any>, HKT.Intro<TC, 'E', E, any>, unknown>>
    ], B, N extends string = HKT.Initial<TC, 'N'>, K = HKT.Initial<TC, 'K'>, Q = HKT.Initial<TC, 'Q'>, W = HKT.Initial<TC, 'W'>, X = HKT.Initial<TC, 'X'>, I = HKT.Initial<TC, 'I'>, S = HKT.Initial<TC, 'S'>, R = HKT.Initial<TC, 'R'>, E = HKT.Initial<TC, 'E'>>(f: (...as: {
        [K in keyof KT]: HKT.Infer<F, TC, 'A', KT[K]>;
    }) => B): (...t: KT) => HKT.Kind<F, TC, InferMixTuple<F, TC, 'N', N, KT>, InferMixTuple<F, TC, 'K', K, KT>, InferMixTuple<F, TC, 'Q', Q, KT>, InferMixTuple<F, TC, 'W', W, KT>, InferMixTuple<F, TC, 'X', X, KT>, InferMixTuple<F, TC, 'I', I, KT>, InferMixTuple<F, TC, 'S', S, KT>, InferMixTuple<F, TC, 'R', R, KT>, InferMixTuple<F, TC, 'E', E, KT>, B>;
}
export interface MapNFn_<F extends HKT.URIS, TC = HKT.Auto> {
    <KT extends readonly [
        HKT.Kind<F, TC, HKT.Intro<TC, 'N', N, any>, HKT.Intro<TC, 'K', K, any>, HKT.Intro<TC, 'Q', Q, any>, HKT.Intro<TC, 'W', W, any>, HKT.Intro<TC, 'X', X, any>, HKT.Intro<TC, 'I', I, any>, HKT.Intro<TC, 'S', S, any>, HKT.Intro<TC, 'R', R, any>, HKT.Intro<TC, 'E', E, any>, unknown>,
        ...ReadonlyArray<HKT.Kind<F, TC, HKT.Intro<TC, 'N', N, any>, HKT.Intro<TC, 'K', K, any>, HKT.Intro<TC, 'Q', Q, any>, HKT.Intro<TC, 'W', W, any>, HKT.Intro<TC, 'X', X, any>, HKT.Intro<TC, 'I', I, any>, HKT.Intro<TC, 'S', S, any>, HKT.Intro<TC, 'R', R, any>, HKT.Intro<TC, 'E', E, any>, unknown>>
    ], N extends string = HKT.Initial<TC, 'N'>, K = HKT.Initial<TC, 'K'>, Q = HKT.Initial<TC, 'Q'>, W = HKT.Initial<TC, 'W'>, X = HKT.Initial<TC, 'X'>, I = HKT.Initial<TC, 'I'>, S = HKT.Initial<TC, 'S'>, R = HKT.Initial<TC, 'R'>, E = HKT.Initial<TC, 'E'>>(...t: KT): <B>(f: (...as: {
        [K in keyof KT]: HKT.Infer<F, TC, 'A', KT[K]>;
    }) => B) => HKT.Kind<F, TC, InferMixTuple<F, TC, 'N', N, KT>, InferMixTuple<F, TC, 'K', K, KT>, InferMixTuple<F, TC, 'Q', Q, KT>, InferMixTuple<F, TC, 'W', W, KT>, InferMixTuple<F, TC, 'X', X, KT>, InferMixTuple<F, TC, 'I', I, KT>, InferMixTuple<F, TC, 'S', S, KT>, InferMixTuple<F, TC, 'R', R, KT>, InferMixTuple<F, TC, 'E', E, KT>, B>;
}
/**
 * ```haskell
 * mapNF :: Apply f => ([a, b, ...] -> c) -> [f a, f b, ...] -> f c
 * ```
 *
 * Combines a tuple of the given `Apply` member and maps with function `f`
 *
 * @category Apply
 * @since 1.0.0
 */
export declare function mapNF<F extends HKT.URIS, C = HKT.Auto>(A: SemimonoidalFunctor<F, C>): MapNFn<F, C>;
/**
 * ```haskell
 * mapNF_ :: Apply f => (fa, fb, ...) -> ([a, b, ...] -> c) -> f c
 * ```
 *
 * Combines a tuple of the given `Apply` member and maps with function `f`
 *
 * @category Apply
 * @since 1.0.0
 */
export declare function mapNF_<F extends HKT.URIS, C = HKT.Auto>(A: SemimonoidalFunctor<F, C>): MapNFn_<F, C>;
export interface SequenceSFn<F extends HKT.URIS, TC = HKT.Auto> {
    <KS extends Readonly<Record<string, HKT.Kind<F, TC, HKT.Intro<TC, 'N', N, any>, HKT.Intro<TC, 'K', K, any>, HKT.Intro<TC, 'Q', Q, any>, HKT.Intro<TC, 'W', W, any>, HKT.Intro<TC, 'X', X, any>, HKT.Intro<TC, 'I', I, any>, HKT.Intro<TC, 'S', S, any>, HKT.Intro<TC, 'R', R, any>, HKT.Intro<TC, 'E', E, any>, unknown>>>, N extends string = HKT.Initial<TC, 'N'>, K = HKT.Initial<TC, 'K'>, Q = HKT.Initial<TC, 'Q'>, W = HKT.Initial<TC, 'W'>, X = HKT.Initial<TC, 'X'>, I = HKT.Initial<TC, 'I'>, S = HKT.Initial<TC, 'S'>, R = HKT.Initial<TC, 'R'>, E = HKT.Initial<TC, 'E'>>(r: EnforceNonEmptyRecord<KS> & Readonly<Record<string, HKT.Kind<F, TC, HKT.Intro<TC, 'N', N, any>, HKT.Intro<TC, 'K', K, any>, HKT.Intro<TC, 'Q', Q, any>, HKT.Intro<TC, 'W', W, any>, HKT.Intro<TC, 'X', X, any>, HKT.Intro<TC, 'I', I, any>, HKT.Intro<TC, 'S', S, any>, HKT.Intro<TC, 'R', R, any>, HKT.Intro<TC, 'E', E, any>, unknown>>>): HKT.Kind<F, TC, InferMixStruct<F, TC, 'N', N, KS>, InferMixStruct<F, TC, 'K', K, KS>, InferMixStruct<F, TC, 'Q', Q, KS>, InferMixStruct<F, TC, 'W', W, KS>, InferMixStruct<F, TC, 'X', X, KS>, InferMixStruct<F, TC, 'I', I, KS>, InferMixStruct<F, TC, 'S', S, KS>, InferMixStruct<F, TC, 'R', R, KS>, InferMixStruct<F, TC, 'E', E, KS>, {
        [K in keyof KS]: HKT.Infer<F, TC, 'A', KS[K]>;
    }>;
}
export declare function sequenceSF<F extends HKT.URIS, C = HKT.Auto>(F: SemimonoidalFunctor<F, C>): SequenceSFn<F, C>;
export interface SequenceTFn<F extends HKT.URIS, TC = HKT.Auto> {
    <KT extends readonly [
        HKT.Kind<F, TC, HKT.Intro<TC, 'N', N, any>, HKT.Intro<TC, 'K', K, any>, HKT.Intro<TC, 'Q', Q, any>, HKT.Intro<TC, 'W', W, any>, HKT.Intro<TC, 'X', X, any>, HKT.Intro<TC, 'I', I, any>, HKT.Intro<TC, 'S', S, any>, HKT.Intro<TC, 'R', R, any>, HKT.Intro<TC, 'E', E, any>, unknown>,
        ...ReadonlyArray<HKT.Kind<F, TC, HKT.Intro<TC, 'N', N, any>, HKT.Intro<TC, 'K', K, any>, HKT.Intro<TC, 'Q', Q, any>, HKT.Intro<TC, 'W', W, any>, HKT.Intro<TC, 'X', X, any>, HKT.Intro<TC, 'I', I, any>, HKT.Intro<TC, 'S', S, any>, HKT.Intro<TC, 'R', R, any>, HKT.Intro<TC, 'E', E, any>, unknown>>
    ], N extends string = HKT.Initial<TC, 'N'>, K = HKT.Initial<TC, 'K'>, Q = HKT.Initial<TC, 'Q'>, W = HKT.Initial<TC, 'W'>, X = HKT.Initial<TC, 'X'>, I = HKT.Initial<TC, 'I'>, S = HKT.Initial<TC, 'S'>, R = HKT.Initial<TC, 'R'>, E = HKT.Initial<TC, 'E'>>(...t: KT): HKT.Kind<F, TC, InferMixTuple<F, TC, 'N', N, KT>, InferMixTuple<F, TC, 'K', K, KT>, InferMixTuple<F, TC, 'Q', Q, KT>, InferMixTuple<F, TC, 'W', W, KT>, InferMixTuple<F, TC, 'X', X, KT>, InferMixTuple<F, TC, 'I', I, KT>, InferMixTuple<F, TC, 'S', S, KT>, InferMixTuple<F, TC, 'R', R, KT>, InferMixTuple<F, TC, 'E', E, KT>, {
        [K in keyof KT]: HKT.Infer<F, TC, 'A', KT[K]>;
    }>;
}
export declare function sequenceTF<F extends HKT.URIS, C = HKT.Auto>(F: SemimonoidalFunctor<F, C>): SequenceTFn<F, C>;
/**
 * @internal
 */
declare type InferMixStruct<F extends HKT.URIS, TC, P extends HKT.Param, T, KS> = HKT.MixStruct<TC, P, T, {
    [K in keyof KS]: HKT.Infer<F, TC, P, KS[K]>;
}>;
/**
 * @internal
 */
declare type InferMixTuple<F extends HKT.URIS, TC, P extends HKT.Param, T, KT> = HKT.MixStruct<TC, P, T, {
    [K in keyof KT & number]: HKT.Infer<F, TC, P, KT[K]>;
}>;
export {};
//# sourceMappingURL=SemimonoidalFunctor.d.ts.map