import type * as HKT from "@principia/prelude/HKT";
import type * as Ac from "../Async";
import { _AI } from "../Async/constants";
import { _A, _E, _I, _R, _U, TaskInstructionTag } from "../Task/Task/constants";
import type * as T from "../Task/Task/model";
export declare const URI = "XPure";
export declare type URI = typeof URI;
export declare type V = HKT.V<"S", "_"> & HKT.V<"R", "-"> & HKT.V<"E", "+">;
declare module "@principia/prelude/HKT" {
   interface URItoKind<FC, TC, N, K, Q, W, X, I, S, R, E, A> {
      readonly [URI]: XPure<S, S, R, E, A>;
   }
}
export declare const _XPI = "_XPI";
export declare type _XPI = typeof _XPI;
/**
 * `XPure<S1, S2, R, E, A>` is a purely functional description of a computation
 * that requires an environment `R` and an initial state `S1` and may either
 * fail with an `E` or succeed with an updated state `S2` and an `A`. Because
 * of its polymorphism `XPure` can be used to model a variety of effects
 * including context, state, and failure.
 */
export declare abstract class XPure<S1, S2, R, E, A> {
   readonly _tag = TaskInstructionTag.Integration;
   readonly _asyncTag = "XPure";
   readonly _S1: (_: S1) => void;
   readonly _S2: () => S2;
   readonly [_U]: T.URI;
   readonly [_E]: () => E;
   readonly [_A]: () => A;
   readonly [_R]: (_: R) => void;
   get [_I](): T.Instruction;
   get [_AI](): Ac.AsyncInstruction;
   get [_XPI](): Instruction;
}
export declare enum XPureInstructionTag {
   Succeed = "Succeed",
   Total = "Total",
   Partial = "Partial",
   Suspend = "Suspend",
   Fail = "Fail",
   Modify = "Modify",
   Chain = "Chain",
   Fold = "Fold",
   Asks = "Asks",
   Give = "Give"
}
export declare class SucceedInstruction<A> extends XPure<unknown, never, unknown, never, A> {
   readonly value: A;
   readonly _xptag = XPureInstructionTag.Succeed;
   constructor(value: A);
}
export declare class TotalInstruction<A> extends XPure<unknown, never, unknown, never, A> {
   readonly thunk: () => A;
   readonly _xptag = XPureInstructionTag.Total;
   constructor(thunk: () => A);
}
export declare class PartialInstruction<E, A> extends XPure<unknown, never, unknown, E, A> {
   readonly thunk: () => A;
   readonly onThrow: (u: unknown) => E;
   readonly _xptag = XPureInstructionTag.Partial;
   constructor(thunk: () => A, onThrow: (u: unknown) => E);
}
export declare class SuspendInstruction<S1, S2, R, E, A> extends XPure<S1, S2, R, E, A> {
   readonly factory: () => XPure<S1, S2, R, E, A>;
   readonly _xptag = XPureInstructionTag.Suspend;
   constructor(factory: () => XPure<S1, S2, R, E, A>);
}
export declare class FailInstruction<E> extends XPure<unknown, never, unknown, E, never> {
   readonly e: E;
   readonly _xptag = XPureInstructionTag.Fail;
   constructor(e: E);
}
export declare class ModifyInstruction<S1, S2, A> extends XPure<S1, S2, unknown, never, A> {
   readonly run: (s1: S1) => readonly [S2, A];
   readonly _xptag = XPureInstructionTag.Modify;
   constructor(run: (s1: S1) => readonly [S2, A]);
}
export declare class ChainInstruction<S1, S2, R, E, A, S3, Q, D, B> extends XPure<S1, S3, Q & R, D | E, B> {
   readonly ma: XPure<S1, S2, R, E, A>;
   readonly f: (a: A) => XPure<S2, S3, Q, D, B>;
   readonly _xptag = XPureInstructionTag.Chain;
   constructor(ma: XPure<S1, S2, R, E, A>, f: (a: A) => XPure<S2, S3, Q, D, B>);
}
export declare class FoldInstruction<S1, S2, S5, R, E, A, S3, R1, E1, B, S4, R2, E2, C> extends XPure<
   S1 & S5,
   S3 | S4,
   R & R1 & R2,
   E1 | E2,
   B | C
> {
   readonly fa: XPure<S1, S2, R, E, A>;
   readonly onFailure: (e: E) => XPure<S5, S3, R1, E1, B>;
   readonly onSuccess: (a: A) => XPure<S2, S4, R2, E2, C>;
   readonly _xptag = XPureInstructionTag.Fold;
   constructor(
      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>
   );
}
export declare class AsksInstruction<R0, S1, S2, R, E, A> extends XPure<S1, S2, R0 & R, E, A> {
   readonly f: (r: R0) => XPure<S1, S2, R, E, A>;
   readonly _xptag = XPureInstructionTag.Asks;
   constructor(f: (r: R0) => XPure<S1, S2, R, E, A>);
}
export declare class GiveInstruction<S1, S2, R, E, A> extends XPure<S1, S2, unknown, E, A> {
   readonly fa: XPure<S1, S2, R, E, A>;
   readonly r: R;
   readonly _xptag = XPureInstructionTag.Give;
   constructor(fa: XPure<S1, S2, R, E, A>, r: R);
}
export declare type Instruction =
   | SucceedInstruction<any>
   | FailInstruction<any>
   | ModifyInstruction<any, any, any>
   | ChainInstruction<any, any, any, any, any, any, any, any, any>
   | FoldInstruction<any, any, any, any, any, any, any, any, any, any, any, any, any, any>
   | AsksInstruction<any, any, any, any, any, any>
   | GiveInstruction<any, any, any, any, any>
   | SuspendInstruction<any, any, any, any, any>
   | TotalInstruction<any>
   | PartialInstruction<any, any>;
//# sourceMappingURL=model.d.ts.map