import type * as HKT from "@principia/prelude/HKT";
import type { Sync } from "../Sync";
import { _A, _E, _I, _R, _U, TaskInstructionTag } from "../Task/Task/constants";
import type * as T from "../Task/Task/model";
import type * as Ex from "./AsyncExit";
import { _AI, AsyncInstructionTag } from "./constants";
export declare abstract class Async<R, E, A> implements T.Integration<R, E, A> {
   readonly _tag = TaskInstructionTag.Integration;
   readonly _S1: (_: unknown) => void;
   readonly _S2: () => never;
   readonly [_U]: T.URI;
   readonly [_R]: (_: R) => void;
   readonly [_E]: () => E;
   readonly [_A]: () => A;
   get [_I](): T.Instruction;
   get [_AI](): AsyncInstruction;
}
export declare const URI = "Async";
export declare type URI = typeof URI;
export declare type V = 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]: Async<R, E, A>;
   }
}
export declare type AsyncInstruction =
   | SucceedInstruction<any>
   | SuspendInstruction<any, any, any>
   | PromiseInstruction<any, any>
   | ChainInstruction<any, any, any, any, any, any>
   | FoldInstruction<any, any, any, any, any, any, any, any, any>
   | AsksInstruction<any, any, any, any>
   | DoneInstruction<any, any>
   | GiveInstruction<any, any, any>
   | FinalizeInstruction<any, any, any, any, any>
   | AllInstruction<any, any, any>
   | FailInstruction<any>
   | TotalInstruction<any>
   | PartialInstruction<any, any>
   | Sync<any, any, any>;
export declare class SucceedInstruction<A> extends Async<unknown, never, A> {
   readonly value: A;
   readonly _asyncTag = AsyncInstructionTag.Succeed;
   constructor(value: A);
}
export declare class TotalInstruction<A> extends Async<unknown, never, A> {
   readonly thunk: () => A;
   readonly _asyncTag = AsyncInstructionTag.Total;
   constructor(thunk: () => A);
}
export declare class PartialInstruction<E, A> extends Async<unknown, E, A> {
   readonly thunk: () => A;
   readonly onThrow: (error: unknown) => E;
   readonly _asyncTag = AsyncInstructionTag.Partial;
   constructor(thunk: () => A, onThrow: (error: unknown) => E);
}
export declare class DoneInstruction<E, A> extends Async<unknown, E, A> {
   readonly exit: Ex.AsyncExit<E, A>;
   readonly _asyncTag = AsyncInstructionTag.Done;
   constructor(exit: Ex.AsyncExit<E, A>);
}
export declare class FailInstruction<E> extends Async<unknown, E, never> {
   readonly e: E;
   readonly _asyncTag = AsyncInstructionTag.Fail;
   constructor(e: E);
}
export declare class AsksInstruction<R0, R, E, A> extends Async<R & R0, E, A> {
   readonly f: (_: R0) => Async<R, E, A>;
   readonly _asyncTag = AsyncInstructionTag.Asks;
   constructor(f: (_: R0) => Async<R, E, A>);
}
export declare class GiveInstruction<R, E, A> extends Async<unknown, E, A> {
   readonly async: Async<R, E, A>;
   readonly env: R;
   readonly _asyncTag = AsyncInstructionTag.Give;
   constructor(async: Async<R, E, A>, env: R);
}
export declare class AllInstruction<R, E, A> extends Async<R, E, readonly A[]> {
   readonly asyncs: readonly Async<R, E, A>[];
   readonly _asyncTag = AsyncInstructionTag.All;
   constructor(asyncs: readonly Async<R, E, A>[]);
}
export declare class SuspendInstruction<R, E, A> extends Async<R, E, A> {
   readonly async: () => Async<R, E, A>;
   readonly _asyncTag = AsyncInstructionTag.Suspend;
   constructor(async: () => Async<R, E, A>);
}
export declare class PromiseInstruction<E, A> extends Async<unknown, E, A> {
   readonly promise: (onInterrupt: (f: () => void) => void) => Promise<A>;
   readonly onReject: (reason: unknown) => E;
   readonly _asyncTag = AsyncInstructionTag.Promise;
   constructor(promise: (onInterrupt: (f: () => void) => void) => Promise<A>, onReject: (reason: unknown) => E);
}
export declare class ChainInstruction<R, E, A, Q, D, B> extends Async<Q & R, D | E, B> {
   readonly async: Async<R, E, A>;
   readonly f: (a: A) => Async<Q, D, B>;
   readonly _asyncTag = AsyncInstructionTag.Chain;
   constructor(async: Async<R, E, A>, f: (a: A) => Async<Q, D, B>);
}
export declare class FoldInstruction<R, E, A, R1, E1, B, R2, E2, C> extends Async<R & R1 & R2, E1 | E2, B | C> {
   readonly async: Async<R, E, A>;
   readonly f: (e: E) => Async<R1, E1, B>;
   readonly g: (a: A) => Async<R2, E2, C>;
   readonly _asyncTag = AsyncInstructionTag.Fold;
   constructor(async: Async<R, E, A>, f: (e: E) => Async<R1, E1, B>, g: (a: A) => Async<R2, E2, C>);
}
export declare class FinalizeInstruction<R, E, A, R1, B> extends Async<R & R1, E, A> {
   readonly async: Async<R, E, A>;
   readonly f: () => Async<R1, never, B>;
   readonly _asyncTag = AsyncInstructionTag.Finalize;
   constructor(async: Async<R, E, A>, f: () => Async<R1, never, B>);
}
//# sourceMappingURL=model.d.ts.map