import { Lazy } from "@tsplus/stdlib/data/Function";
import { RuntimeConfig } from "@effect/core/io/RuntimeConfig/definition";
import { FiberId } from "@effect/core/io/FiberId/definition";
import { Either } from "@tsplus/stdlib/data/Either/definition";
import { Cause } from "@effect/core/io/Cause/definition";
import { Fiber } from "@effect/core/io/Fiber/definition";
import { Maybe } from "@tsplus/stdlib/data/Maybe/definition";
import { FiberScope } from "@effect/core/io/FiberScope/definition";
import { InterruptStatus } from "@effect/core/io/InterruptStatus/definition";
import { FiberRefs } from "@effect/core/io/FiberRefs/definition";
import { Tuple } from "@tsplus/stdlib/data/Tuple/definition";
import { FiberRef } from "@effect/core/io/FiberRef/definition";
import { Trace } from "@effect/core/io/Trace/definition";
import { Supervisor } from "@effect/core/io/Supervisor/definition";
import { LogLevel } from "@effect/core/io/LogLevel/definition";
import type { Effect } from "@effect/core/io/Effect/definition/base";
import { Base } from "@effect/core/io/Effect/definition/base";
export declare type Instruction = IFlatMap<any, any, any, any, any, any> | IFold<any, any, any, any, any, any, any, any, any> | IEnsuring<any, any, any, any> | ISucceedNow<any> | IFail<any> | ISucceed<any> | ISucceedWith<any> | ISuspend<any, any, any> | ISuspendWith<any, any, any> | IAsync<any, any, any> | IInterruptStatus<any, any, any> | ICheckInterrupt<any, any, any> | IFork<any, any, any> | IDescriptor<any, any, any> | IYield | IFiberRefModify<any, any, any> | ITrace | IRaceWith<any, any, any, any, any, any, any, any, any, any, any, any> | ISupervise<any, any, any> | IGetForkScope<any, any, any> | IOverrideForkScope<any, any, any> | ILogged<any> | IFiberRefModifyAll<any> | IFiberRefLocally<any, any, any, any, any> | IFiberRefDelete | IFiberRefWith<any, any, any, any, any> | ISetRuntimeConfig;
export declare class IFlatMap<R, E, A, R1, E1, A1> extends Base<R | R1, E | E1, A1> {
    readonly effect: Effect<R, E, A>;
    readonly k: (a: A) => Effect<R1, E1, A1>;
    readonly trace?: string | undefined;
    readonly _tag = "FlatMap";
    constructor(effect: Effect<R, E, A>, k: (a: A) => Effect<R1, E1, A1>, trace?: string | undefined);
    apply(a: A): Effect<R1, E1, A1>;
    unsafeLog(): string;
}
export declare class ISucceedNow<A> extends Base<never, never, A> {
    readonly value: A;
    readonly trace?: string | undefined;
    readonly _tag = "SucceedNow";
    constructor(value: A, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class ISucceed<A> extends Base<never, never, A> {
    readonly effect: Lazy<A>;
    readonly trace?: string | undefined;
    readonly _tag = "Succeed";
    constructor(effect: Lazy<A>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class ISucceedWith<A> extends Base<never, never, A> {
    readonly effect: (runtimeConfig: RuntimeConfig, id: FiberId) => A;
    readonly trace?: string | undefined;
    readonly _tag = "SucceedWith";
    constructor(effect: (runtimeConfig: RuntimeConfig, id: FiberId) => A, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class ISuspend<R, E, A> extends Base<R, E, A> {
    readonly make: Lazy<Effect<R, E, A>>;
    readonly trace?: string | undefined;
    readonly _tag = "Suspend";
    constructor(make: Lazy<Effect<R, E, A>>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class ISuspendWith<R, E, A> extends Base<R, E, A> {
    readonly make: (runtimeConfig: RuntimeConfig, id: FiberId) => Effect<R, E, A>;
    readonly trace?: string | undefined;
    readonly _tag = "SuspendWith";
    constructor(make: (runtimeConfig: RuntimeConfig, id: FiberId) => Effect<R, E, A>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IAsync<R, E, A> extends Base<R, E, A> {
    readonly register: (cb: (_: Effect<R, E, A>) => void) => Either<Effect<R, never, void>, Effect<R, E, A>>;
    readonly blockingOn: Lazy<FiberId>;
    readonly trace?: string | undefined;
    readonly _tag = "Async";
    constructor(register: (cb: (_: Effect<R, E, A>) => void) => Either<Effect<R, never, void>, Effect<R, E, A>>, blockingOn: Lazy<FiberId>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IFold<R, E, A, R2, E2, A2, R3, E3, A3> extends Base<R | R2 | R3, E2 | E3, A2 | A3> {
    readonly effect: Effect<R, E, A>;
    readonly failure: (cause: Cause<E>) => Effect<R2, E2, A2>;
    readonly success: (a: A) => Effect<R3, E3, A3>;
    readonly trace?: string | undefined;
    readonly _tag = "Fold";
    constructor(effect: Effect<R, E, A>, failure: (cause: Cause<E>) => Effect<R2, E2, A2>, success: (a: A) => Effect<R3, E3, A3>, trace?: string | undefined);
    apply(a: A): Effect<R3, E3, A3>;
    unsafeLog(): string;
}
export declare class IFork<R, E, A> extends Base<R, never, Fiber.Runtime<E, A>> {
    readonly effect: Effect<R, E, A>;
    readonly scope: Lazy<Maybe<FiberScope>>;
    readonly trace?: string | undefined;
    readonly _tag = "Fork";
    constructor(effect: Effect<R, E, A>, scope: Lazy<Maybe<FiberScope>>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IInterruptStatus<R, E, A> extends Base<R, E, A> {
    readonly effect: Effect<R, E, A>;
    readonly flag: Lazy<InterruptStatus>;
    readonly trace?: string | undefined;
    readonly _tag = "InterruptStatus";
    constructor(effect: Effect<R, E, A>, flag: Lazy<InterruptStatus>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class ICheckInterrupt<R, E, A> extends Base<R, E, A> {
    readonly k: (_: InterruptStatus) => Effect<R, E, A>;
    readonly trace?: string | undefined;
    readonly _tag = "CheckInterrupt";
    constructor(k: (_: InterruptStatus) => Effect<R, E, A>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IFail<E> extends Base<never, E, never> {
    readonly cause: Lazy<Cause<E>>;
    readonly trace?: string | undefined;
    readonly _tag = "Fail";
    constructor(cause: Lazy<Cause<E>>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IDescriptor<R, E, A> extends Base<R, E, A> {
    readonly f: (_: Fiber.Descriptor) => Effect<R, E, A>;
    readonly trace?: string | undefined;
    readonly _tag = "Descriptor";
    constructor(f: (_: Fiber.Descriptor) => Effect<R, E, A>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IYield extends Base<never, never, void> {
    readonly trace?: string | undefined;
    readonly _tag = "Yield";
    constructor(trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IFiberRefModifyAll<A> extends Base<never, never, A> {
    readonly f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => Tuple<[A, FiberRefs]>;
    readonly trace?: string | undefined;
    readonly _tag = "FiberRefModifyAll";
    constructor(f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => Tuple<[A, FiberRefs]>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IFiberRefModify<A, B, P> extends Base<never, never, B> {
    readonly fiberRef: FiberRef<A, P>;
    readonly f: (a: A) => Tuple<[B, A]>;
    readonly trace?: string | undefined;
    readonly _tag = "FiberRefModify";
    constructor(fiberRef: FiberRef<A, P>, f: (a: A) => Tuple<[B, A]>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IFiberRefLocally<V, R, E, A, P> extends Base<R, E, A> {
    readonly localValue: V;
    readonly fiberRef: FiberRef<V, P>;
    readonly effect: Effect<R, E, A>;
    readonly trace?: string | undefined;
    readonly _tag = "FiberRefLocally";
    constructor(localValue: V, fiberRef: FiberRef<V, P>, effect: Effect<R, E, A>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IFiberRefDelete extends Base<never, never, void> {
    readonly fiberRef: FiberRef<unknown, unknown>;
    readonly trace?: string | undefined;
    readonly _tag = "FiberRefDelete";
    constructor(fiberRef: FiberRef<unknown, unknown>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IFiberRefWith<R, E, A, B, P> extends Base<R, E, B> {
    readonly fiberRef: FiberRef<A, P>;
    readonly f: (a: A) => Effect<R, E, B>;
    readonly trace?: string | undefined;
    readonly _tag = "FiberRefWith";
    constructor(fiberRef: FiberRef<A, P>, f: (a: A) => Effect<R, E, B>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class ITrace extends Base<never, never, Trace> {
    readonly trace?: string | undefined;
    readonly _tag = "Trace";
    constructor(trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IRaceWith<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends Base<R | R1 | R2 | R3, E2 | E3, A2 | A3> {
    readonly left: Lazy<Effect<R, E, A>>;
    readonly right: Lazy<Effect<R1, E1, A1>>;
    readonly leftWins: (winner: Fiber<E, A>, loser: Fiber<E1, A1>) => Effect<R2, E2, A2>;
    readonly rightWins: (winner: Fiber<E1, A1>, loser: Fiber<E, A>) => Effect<R3, E3, A3>;
    readonly trace?: string | undefined;
    readonly _tag = "RaceWith";
    constructor(left: Lazy<Effect<R, E, A>>, right: Lazy<Effect<R1, E1, A1>>, leftWins: (winner: Fiber<E, A>, loser: Fiber<E1, A1>) => Effect<R2, E2, A2>, rightWins: (winner: Fiber<E1, A1>, loser: Fiber<E, A>) => Effect<R3, E3, A3>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class ISupervise<R, E, A> extends Base<R, E, A> {
    readonly effect: Effect<R, E, A>;
    readonly supervisor: Lazy<Supervisor<any>>;
    readonly trace?: string | undefined;
    readonly _tag = "Supervise";
    constructor(effect: Effect<R, E, A>, supervisor: Lazy<Supervisor<any>>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IGetForkScope<R, E, A> extends Base<R, E, A> {
    readonly f: (_: FiberScope) => Effect<R, E, A>;
    readonly trace?: string | undefined;
    readonly _tag = "GetForkScope";
    constructor(f: (_: FiberScope) => Effect<R, E, A>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IOverrideForkScope<R, E, A> extends Base<R, E, A> {
    readonly effect: Effect<R, E, A>;
    readonly forkScope: Maybe<FiberScope>;
    readonly trace?: string | undefined;
    readonly _tag = "OverrideForkScope";
    constructor(effect: Effect<R, E, A>, forkScope: Maybe<FiberScope>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class IEnsuring<R, R1, E, A> extends Base<R, E, A> {
    readonly effect: Effect<R, E, A>;
    readonly finalizer: Effect<R1, never, unknown>;
    readonly trace?: string | undefined;
    readonly _tag = "Ensuring";
    constructor(effect: Effect<R, E, A>, finalizer: Effect<R1, never, unknown>, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class ILogged<A> extends Base<never, never, void> {
    readonly message: Lazy<A>;
    readonly cause: Lazy<Cause<unknown>>;
    readonly overrideLogLevel: Maybe<LogLevel>;
    readonly overrideRef1: FiberRef<unknown, unknown> | null;
    readonly overrideValue1: unknown;
    readonly trace?: string | undefined;
    readonly _tag = "Logged";
    constructor(message: Lazy<A>, cause: Lazy<Cause<unknown>>, overrideLogLevel?: Maybe<LogLevel>, overrideRef1?: FiberRef<unknown, unknown> | null, overrideValue1?: unknown, trace?: string | undefined);
    unsafeLog(): string;
}
export declare class ISetRuntimeConfig extends Base<never, never, void> {
    readonly runtimeConfig: RuntimeConfig;
    readonly trace?: string | undefined;
    readonly _tag = "SetRuntimeConfig";
    constructor(runtimeConfig: RuntimeConfig, trace?: string | undefined);
    unsafeLog(): string;
}
/**
 * @tsplus macro identity
 */
export declare function instruction<R, E, A>(self: Effect<R, E, A>): Instruction;
//# sourceMappingURL=primitives.d.ts.map