import { FiberId } from "@effect/core/io/FiberId/definition";
import { Cause } from "@effect/core/io/Cause/definition";
import { RuntimeFlags } from "@effect/core/io/RuntimeFlags/definition";
import { Hash } from "@tsplus/stdlib/structure/Hash";
import { Equals } from "@tsplus/stdlib/structure/Equals";
import type { Effect } from "@effect/core/io/Effect/definition/base";
import { EffectURI } from "@effect/core/io/Effect/definition/base";
import type { FiberRuntime } from "@effect/core/io/Fiber/_internal/runtime";
import type { Running } from "@effect/core/io/Fiber/status";
export type ErasedEffect = ISync<any> | IAsync<any, any, any> | IOnSuccessAndFailure<any, any, any, any, any, any, any, any, any> | IOnSuccess<any, any, any, any, any, any> | IOnFailure<any, any, any, any, any, any> | IUpdateRuntimeFlags | IUpdateRuntimeFlagsDynamic<any, any, any> | IStateful<any, any, any> | IWhileLoop<any, any, any> | IYieldNow | IFailure<any> | ISuccess<any> | ICommit<any, any, any>;
export declare class ISync<A> implements Effect<never, never, A> {
    readonly evaluate: () => A;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "Sync";
    constructor(evaluate: () => A);
}
export interface ICommit<R, E, A> extends Effect<R, E, A> {
    readonly _tag: "ICommit";
    readonly commit: Effect<R, E, A>;
}
export declare class IAsync<R, E, A> implements Effect<R, E, A> {
    readonly register: (resume: (effect: Effect<R, E, A>) => void) => void;
    readonly blockingOn: FiberId;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "Async";
    constructor(register: (resume: (effect: Effect<R, E, A>) => void) => void, blockingOn: FiberId);
}
export declare class IOnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> implements Effect<R | R1 | R2, E1 | E2, B | C> {
    readonly first: Effect<R, E, A>;
    readonly successK: (a: A) => Effect<R1, E1, B>;
    readonly failK: (e: Cause<E>) => Effect<R2, E2, C>;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "OnSuccessAndFailure";
    constructor(first: Effect<R, E, A>, successK: (a: A) => Effect<R1, E1, B>, failK: (e: Cause<E>) => Effect<R2, E2, C>);
}
export declare class IOnSuccess<R, E, A, R1, E1, B> implements Effect<R | R1, E | E1, B> {
    readonly first: Effect<R, E, A>;
    readonly successK: (a: A) => Effect<R1, E1, B>;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "OnSuccess";
    constructor(first: Effect<R, E, A>, successK: (a: A) => Effect<R1, E1, B>);
}
export declare class IOnFailure<R, E, A, R1, E1, B> implements Effect<R | R1, E1, A | B> {
    readonly first: Effect<R, E, A>;
    readonly failK: (a: Cause<E>) => Effect<R1, E1, B>;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "OnFailure";
    constructor(first: Effect<R, E, A>, failK: (a: Cause<E>) => Effect<R1, E1, B>);
}
export declare class IUpdateRuntimeFlags implements Effect<never, never, void> {
    readonly update: RuntimeFlags.Patch;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "UpdateRuntimeFlags";
    constructor(update: RuntimeFlags.Patch);
}
export declare class IUpdateRuntimeFlagsDynamic<R, E, A> implements Effect<R, E, A> {
    readonly update: RuntimeFlags.Patch;
    readonly scope: (oldRuntimeFlags: RuntimeFlags) => Effect<R, E, A>;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "UpdateRuntimeFlagsWithin";
    constructor(update: RuntimeFlags.Patch, scope: (oldRuntimeFlags: RuntimeFlags) => Effect<R, E, A>);
}
export declare class IUpdateRuntimeFlagsInterruptible<R, E, A> implements IUpdateRuntimeFlagsDynamic<R, E, A> {
    readonly effect: Effect<R, E, A>;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "UpdateRuntimeFlagsWithin";
    readonly update: RuntimeFlags.Patch;
    readonly scope: (oldRuntimeFlags: RuntimeFlags) => Effect<R, E, A>;
    constructor(effect: Effect<R, E, A>);
}
export declare class IUpdateRuntimeFlagsUninterruptible<R, E, A> implements IUpdateRuntimeFlagsDynamic<R, E, A> {
    readonly effect: Effect<R, E, A>;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "UpdateRuntimeFlagsWithin";
    readonly update: RuntimeFlags.Patch;
    readonly scope: (oldRuntimeFlags: RuntimeFlags) => Effect<R, E, A>;
    constructor(effect: Effect<R, E, A>);
}
export declare class IStateful<R, E, A> implements Effect<R, E, A> {
    readonly onState: (fiber: FiberRuntime<E, A>, status: Running) => Effect<R, E, A>;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "Stateful";
    constructor(onState: (fiber: FiberRuntime<E, A>, status: Running) => Effect<R, E, A>);
}
export declare class IWhileLoop<R, E, A> implements Effect<R, E, void> {
    readonly check: () => boolean;
    readonly body: () => Effect<R, E, A>;
    readonly process: (a: A) => void;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "WhileLoop";
    constructor(check: () => boolean, body: () => Effect<R, E, A>, process: (a: A) => void);
}
export declare class IYieldNow implements Effect<never, never, void> {
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "YieldNow";
}
export declare class IFailure<E> implements Effect<never, E, never> {
    readonly cause: Cause<E>;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "Failure";
    constructor(cause: Cause<E>);
    [Hash.sym](): number;
    [Equals.sym](that: unknown): boolean;
}
export declare class ISuccess<A> implements Effect<never, never, A> {
    readonly value: A;
    readonly [EffectURI]: {
        _R: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => never;
    };
    readonly _tag = "Success";
    constructor(value: A);
    [Hash.sym](): number;
    [Equals.sym](that: unknown): boolean;
}
//# sourceMappingURL=primitives.d.ts.map