import { HKT } from "@tsplus/stdlib/prelude/HKT";
import { Applicative } from "@tsplus/stdlib/prelude/Applicative";
import { Maybe } from "@tsplus/stdlib/data/Maybe/definition";
/**
 * @tsplus type WitherableWithIndex
 */
export interface WitherableWithIndex<K, F extends HKT> {
    readonly Law: {
        readonly WitherableWithIndex: "WitherableWithIndex";
    };
    readonly compactWithIndexF: WitherWithIndex<K, F>;
}
/**
 * @tsplus type WitherableWithIndex/Ops
 */
export interface WitherableWithIndexOps {
}
export declare const WitherableWithIndex: WitherableWithIndexOps;
export interface WitherWithIndex<K, F extends HKT> extends HKT.Typeclass<F> {
    <G extends HKT>(F: Applicative<G>): <GR, GE, A, B>(f: (k: K, a: A) => HKT.Kind<G, GR, GE, Maybe<B>>) => <FR, FE>(ta: HKT.Kind<F, FR, FE, A>) => HKT.Kind<G, GR, GE, HKT.Kind<F, FR, FE, B>>;
}
/**
 * @tsplus static WitherableWithIndex/Ops implementCompactWithIndexF
 * @tsplus location "@tsplus/stdlib/prelude/WitherableWithIndex"
 */
export declare function implementCompactWithIndexF<K, F extends HKT>(): (i: <FR, FE, A, B, G extends HKT>(_: {
    A: A;
    B: B;
    G: G;
    FR: FR;
    FE: FE;
}) => (G: Applicative<G>) => (f: (k: K, a: A) => HKT.Kind<G, FR, FE, Maybe<B>>) => (ta: HKT.Kind<F, FR, FE, A>) => HKT.Kind<G, FR, FE, HKT.Kind<F, FR, FE, B>>) => WitherWithIndex<K, F>;
//# sourceMappingURL=WitherableWithIndex.d.ts.map