import type { XPure } from "./model";
/**
 * ```haskell
 * foldM_ :: (
 *    XPure s1 s2 r e a,
 *    (e -> XPure s3 s4 r1 e1 b),
 *    (a -> XPure s2 s5 r2 e2 c)
 * ) -> XPure (s1 & s3) (s4 | s5) (r & r1 & r2) (b | c)
 * ```
 *
 * Recovers from errors by accepting one computation to execute for the case
 * of an error, and one computation to execute for the case of success.
 *
 * @category Combinators
 * @since 1.0.0
 */
export declare const foldM_: <S1, S5, S2, R, E, A, S3, R1, E1, B, S4, R2, E2, C>(
   fa: XPure<S1, S2, R, E, A>,
   onFailure: (e: E) => XPure<S5, S3, R1, E1, B>,
   onSuccess: (a: A) => XPure<S2, S4, R2, E2, C>
) => XPure<S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
/**
 * ```haskell
 * foldM :: (
 *    (e -> XPure s3 s4 r1 e1 b),
 *    (a -> XPure s2 s5 r2 e2 c)
 * ) -> XPure s1 s2 r e a -> XPure (s1 & s3) (s4 | s5) (r & r1 & r2) (b | c)
 * ```
 *
 * Recovers from errors by accepting one computation to execute for the case
 * of an error, and one computation to execute for the case of success.
 *
 * @category Combinators
 * @since 1.0.0
 */
export declare const foldM: <S1, S2, E, A, S3, R1, E1, B, S4, R2, E2, C>(
   onFailure: (e: E) => XPure<S1, S3, R1, E1, B>,
   onSuccess: (a: A) => XPure<S2, S4, R2, E2, C>
) => <R>(fa: XPure<S1, S2, R, E, A>) => XPure<S1, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
/**
 * ```haskell
 * fold_ :: (
 *    XPure s1 s2 r e a,
 *    (e -> b),
 *    (a -> c)
 * ) -> XPure s1 s2 r _ (b | c)
 * ```
 *
 * Folds over the failed or successful results of this computation to yield
 * a computation that does not fail, but succeeds with the value of the left
 * or right function passed to `fold`.
 *
 * @category Combinators
 * @since 1.0.0
 */
export declare const fold_: <S1, S2, R, E, A, B, C>(
   fa: XPure<S1, S2, R, E, A>,
   onFailure: (e: E) => B,
   onSuccess: (a: A) => C
) => XPure<S1, S2, R, never, B | C>;
/**
 * ```haskell
 * fold :: ((e -> b), (a -> c)) -> XPure s1 s2 r e a -> XPure s1 s2 r _ (b | c)
 * ```
 *
 * Folds over the failed or successful results of this computation to yield
 * a computation that does not fail, but succeeds with the value of the left
 * or right function passed to `fold`.
 *
 * @category Combinators
 * @since 1.0.0
 */
export declare const fold: <E, A, B, C>(
   onFailure: (e: E) => B,
   onSuccess: (a: A) => C
) => <S1, S2, R>(fa: XPure<S1, S2, R, E, A>) => XPure<S1, S2, R, never, B | C>;
//# sourceMappingURL=fold.d.ts.map