import { Eval, Kind, TyK, $type, TyVar } from '@fp4ts/core';
import { Monoid } from '@fp4ts/cats-kernel';
import { Monad } from './monad';
import { MonoidK } from './monoid-k';
import { UnorderedFoldable } from './unordered-foldable';
import { Option } from './data';
import { ComposedFoldable } from './composed';
import { ArrayF } from './instances/array';
/**
 * @category Type Class
 */
export interface Foldable<F> extends UnorderedFoldable<F> {
    /**
     * Right associative, lazy fold mapping each element of the structure `Kind<F, [A]>`
     * into a monoid `M` and combining their results using `combineEval`.
     *
     * For a strict version, see `foldMapLeft`.
     */
    foldMap<M>(M: Monoid<M>): <A>(f: (a: A) => M) => (fa: Kind<F, [A]>) => M;
    /**
     * Right associative, lazy fold mapping each element of the structure `Kind<F, [A]>`
     * into a monoid `M` and combining their results using `combineEval`.
     *
     * For a strict version, see `foldMapLeft`.
     */
    foldMap_<M>(M: Monoid<M>): <A>(fa: Kind<F, [A]>, f: (a: A) => M) => M;
    /**
     * Left associative, strict variant of the `foldMap` using monoid's `combine`
     * operator to combine results.
     */
    foldMapLeft<M>(M: Monoid<M>): <A>(f: (a: A) => M) => (fa: Kind<F, [A]>) => M;
    /**
     * Left associative, strict variant of the `foldMap` using monoid's `combine`
     * operator to combine results.
     */
    foldMapLeft_<M>(M: Monoid<M>): <A>(fa: Kind<F, [A]>, f: (a: A) => M) => M;
    /**
     * Right associative, lazy fold of the structure into a lazy accumulated value
     * `Eval<B>`.
     */
    foldRight<A, B>(b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): (fa: Kind<F, [A]>) => Eval<B>;
    /**
     * Right associative, lazy fold of the structure into a lazy accumulated value
     * `Eval<B>`.
     */
    foldRight_<A, B>(fa: Kind<F, [A]>, b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): Eval<B>;
    /**
     * Left associative, strict fold of the structure into an accumulated value `B`.
     */
    foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (fa: Kind<F, [A]>) => B;
    /**
     * Left associative, strict fold of the structure into an accumulated value `B`.
     */
    foldLeft_<A, B>(fa: Kind<F, [A]>, b: B, f: (b: B, a: A) => B): B;
    foldMapK<G>(G: MonoidK<G>): <A, B>(f: (a: A) => Kind<G, [B]>) => (fa: Kind<F, [A]>) => Kind<G, [B]>;
    foldMapK_<G>(G: MonoidK<G>): <A, B>(fa: Kind<F, [A]>, f: (a: A) => Kind<G, [B]>) => Kind<G, [B]>;
    foldM<G>(G: Monad<G>): <A, B>(z: B, f: (b: B, a: A) => Kind<G, [B]>) => (fa: Kind<F, [A]>) => Kind<G, [B]>;
    foldM_<G>(G: Monad<G>): <A, B>(fa: Kind<F, [A]>, z: B, f: (b: B, a: A) => Kind<G, [B]>) => Kind<G, [B]>;
    elem(idx: number): <A>(fa: Kind<F, [A]>) => Option<A>;
    elem_<A>(fa: Kind<F, [A]>, idx: number): Option<A>;
    get(idx: number): <A>(fa: Kind<F, [A]>) => Option<A>;
    get_<A>(fa: Kind<F, [A]>, idx: number): Option<A>;
    iterator<A>(fa: Kind<F, [A]>): Iterator<A>;
    toArray<A>(fa: Kind<F, [A]>): A[];
}
export type FoldableRequirements<F> = (Pick<Foldable<F>, 'foldMap_'> | Pick<Foldable<F>, 'foldRight_'>) & Partial<Foldable<F>>;
export declare const Foldable: Readonly<{
    of: <F>(F: FoldableRequirements<F>) => Foldable<F>;
    compose: <F_1, G>(F: Foldable<F_1>, G: Foldable<G>) => ComposedFoldable<F_1, G>;
    readonly Array: Foldable<ArrayF>;
}>;
export interface FoldableF extends TyK<[unknown]> {
    [$type]: Foldable<TyVar<this, 0>>;
}
//# sourceMappingURL=foldable.d.ts.map