import type * as P from "@principia/prelude";
import * as HKT from "@principia/prelude/HKT";
import type { Monoid } from "@principia/prelude/Monoid";
import type { ReadonlyRecord, URI, V } from "./model";
/**
 * ```haskell
 * reduceWithIndex_ :: (FoldableWithIndex t, Index k) => (t a, b, ((k, b, a) -> b)) -> b
 * ```
 */
export declare const reduceWithIndex_: <N extends string, A, B>(
   fa: Readonly<Record<N, A>>,
   b: B,
   f: (k: N, b: B, a: A) => B
) => B;
/**
 * ```haskell
 * reduceWithIndex :: (FoldableWithIndex t, Index k) =>
 *    (b, ((k, b, a) -> b)) -> t a -> b
 * ```
 */
export declare const reduceWithIndex: <N extends string, A, B>(
   b: B,
   f: (k: N, b: B, a: A) => B
) => (fa: Readonly<Record<N, A>>) => B;
/**
 * ```haskell
 * reduce_ :: Foldable t => (t a, b, ((b, a) -> b)) -> b
 * ```
 */
export declare const reduce_: <N extends string, A, B>(fa: Readonly<Record<N, A>>, b: B, f: (b: B, a: A) => B) => B;
/**
 * ```haskell
 * reduce :: Foldable t => (b, ((b, a) -> b)) -> t a -> b
 * ```
 */
export declare const reduce: <A, B>(b: B, f: (b: B, a: A) => B) => <N extends string>(fa: Readonly<Record<N, A>>) => B;
/**
 * ```haskell
 * reduceRightWithIndex_ :: (FoldableWithIndex t, Index k) =>
 *    (t a, b, ((k, a, b) -> b)) -> b
 * ```
 */
export declare const reduceRightWithIndex_: <N extends string, A, B>(
   fa: Readonly<Record<N, A>>,
   b: B,
   f: (k: N, a: A, b: B) => B
) => B;
/**
 * ```haskell
 * reduceRightWithIndex :: (FoldableWithIndex t, Index k) =>
 *    (b, ((k, a, b) -> b)) -> t a -> b
 * ```
 */
export declare const reduceRightWithIndex: <N extends string, A, B>(
   b: B,
   f: (k: N, a: A, b: B) => B
) => (fa: Readonly<Record<N, A>>) => B;
/**
 * ```haskell
 * reduceRight_ :: Foldable t => (t a, b, ((a, b) -> b)) -> b
 * ```
 */
export declare const reduceRight_: <N extends string, A, B>(
   fa: Readonly<Record<N, A>>,
   b: B,
   f: (a: A, b: B) => B
) => B;
/**
 * ```haskell
 * reduceRight :: Foldable t => (b, ((a, b) -> b)) -> t a -> b
 * ```
 */
export declare const reduceRight: <A, B>(
   b: B,
   f: (a: A, b: B) => B
) => <N extends string>(fa: Readonly<Record<N, A>>) => B;
export declare const foldMapWithIndex_: <M>(
   M: P.Monoid<M>
) => <N extends string, A>(fa: Readonly<Record<N, A>>, f: (k: N, a: A) => M) => M;
export declare const foldMapWithIndex: <M>(
   M: P.Monoid<M>
) => <N extends string, A>(f: (k: N, a: A) => M) => (fa: Readonly<Record<N, A>>) => M;
export declare const foldMap_: <M>(
   M: P.Monoid<M>
) => <N extends string, A>(fa: Readonly<Record<N, A>>, f: (a: A) => M) => M;
export declare const foldMap: <M>(
   M: P.Monoid<M>
) => <A>(f: (a: A) => M) => <N extends string>(fa: Readonly<Record<N, A>>) => M;
export declare const fromFoldableMap: <B, F extends HKT.URIS, C = HKT.Auto>(
   S: P.Semigroup<B>,
   F: P.Foldable<F, C>
) => <NF extends string, KF, QF, WF, XF, IF, SF, RF, EF, A, N extends string>(
   fa: HKT.Kind<F, C, NF, KF, QF, WF, XF, IF, SF, RF, EF, A>,
   f: (a: A) => readonly [N, B]
) => Readonly<Record<N, B>>;
export declare const fromFoldable: <A, F extends HKT.URIS, C = HKT.Auto>(
   S: P.Semigroup<A>,
   F: P.Foldable<F, C>
) => <NF extends string, KF, QF, WF, XF, IF, SF, RF, EF, N extends string>(
   fa: HKT.Kind<F, C, NF, KF, QF, WF, XF, IF, SF, RF, EF, readonly [N, A]>
) => Readonly<Record<N, A>>;
export declare const Foldable: P.Foldable<[URI], V>;
export declare const FoldableWithIndex: P.FoldableWithIndex<[URI], V>;
//# sourceMappingURL=foldable.d.ts.map