import { STM } from "@effect/core/stm/STM/definition/base";
import { FiberId } from "@effect/core/io/FiberId/definition";
import { Env } from "@tsplus/stdlib/service/Env";
import { Lazy, LazyArg } from "@tsplus/stdlib/data/Function";
import { Stack } from "@tsplus/stdlib/data/Stack";
import { TExit } from "@effect/core/stm/TExit/definition";
import { AtomicReference } from "@tsplus/stdlib/data/AtomicReference";
import { Exit } from "@effect/core/io/Exit/definition";
import { TRef } from "@effect/core/stm/TRef/definition";
import { Effect, EffectURI } from "@effect/core/io/Effect/definition";
import { STMTypeId } from "@effect/core/stm/STM/definition/base";
import { State } from "@effect/core/stm/STM/State";
import { TxnId } from "@effect/core/stm/STM/TxnId";
import type { Entry } from "@effect/core/stm/STM/Entry";
import { TryCommit } from "@effect/core/stm/STM/TryCommit";
import type { Scheduler } from "@effect/core/support/Scheduler";
export declare class STMBase<R, E, A> implements STM<R, E, A> {
    readonly _tag = "ICommit";
    readonly [STMTypeId]: {
        _R: (_: never) => R;
        _E: (_: never) => E;
        _A: (_: never) => A;
    };
    readonly [EffectURI]: {
        _R: (_: never) => R;
        _E: (_: never) => E;
        _A: (_: never) => A;
    };
    get commit(): Effect<R, E, A>;
}
export declare class STMEffect<R, E, A> extends STMBase<R, E, A> {
    readonly f: (journal: Journal, fiberId: FiberId, environment: Env<R>) => A;
    readonly _stmtag = "STMEffect";
    constructor(f: (journal: Journal, fiberId: FiberId, environment: Env<R>) => A);
}
export declare class STMOnFailure<R, E, E1, A> extends STMBase<R, E1, A> {
    readonly stm: STM<R, E, A>;
    readonly onFailure: (e: E) => STM<R, E1, A>;
    readonly _stmtag = "STMOnFailure";
    constructor(stm: STM<R, E, A>, onFailure: (e: E) => STM<R, E1, A>);
    apply(a: A): STM<R, E, A>;
}
export declare class STMOnRetry<R, E, A, R1, E1, A1> extends STMBase<R, E, A> {
    readonly stm: STM<R, E, A>;
    readonly onRetry: Lazy<STM<R1, E1, A1>>;
    readonly _stmtag = "STMOnRetry";
    constructor(stm: STM<R, E, A>, onRetry: Lazy<STM<R1, E1, A1>>);
    apply(a: A): STM<R, E, A>;
}
export declare class STMOnSuccess<R, E, A, B> extends STMBase<R, E, B> {
    readonly stm: STM<R, E, A>;
    readonly apply: (a: A) => STM<R, E, B>;
    readonly _stmtag = "STMOnSuccess";
    constructor(stm: STM<R, E, A>, apply: (a: A) => STM<R, E, B>);
}
export declare class STMProvide<R0, R, E, A> extends STMBase<R, E, A> {
    readonly stm: STM<R0, E, A>;
    readonly f: (env: Env<R>) => Env<R0>;
    readonly _stmtag = "STMProvide";
    constructor(stm: STM<R0, E, A>, f: (env: Env<R>) => Env<R0>);
}
export declare class STMSucceedNow<R, E, A> extends STMBase<R, E, A> {
    readonly a: A;
    readonly _stmtag = "STMSucceedNow";
    constructor(a: A);
}
export declare class STMSucceed<R, E, A> extends STMBase<R, E, A> {
    readonly a: Lazy<A>;
    readonly _stmtag = "STMSucceed";
    constructor(a: Lazy<A>);
}
export declare const STMFailExceptionSym: unique symbol;
export type STMFailExceptionSym = typeof STMFailExceptionSym;
export declare class STMFailException<E> {
    readonly e: E;
    readonly [STMFailExceptionSym]: STMFailExceptionSym;
    constructor(e: E);
}
/**
 * @tsplus static effect/core/stm/STM.Ops isFailException
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function isFailException(u: unknown): u is STMFailException<unknown>;
export declare const STMDieExceptionSym: unique symbol;
export type STMDieExceptionSym = typeof STMDieExceptionSym;
export declare class STMDieException<E> {
    readonly e: E;
    readonly [STMDieExceptionSym]: STMDieExceptionSym;
    constructor(e: E);
}
/**
 * @tsplus static effect/core/stm/STM.Ops isDieException
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function isDieException(u: unknown): u is STMDieException<unknown>;
export declare const STMInterruptExceptionSym: unique symbol;
export type STMInterruptExceptionSym = typeof STMInterruptExceptionSym;
export declare class STMInterruptException {
    readonly fiberId: FiberId;
    readonly [STMInterruptExceptionSym]: STMInterruptExceptionSym;
    constructor(fiberId: FiberId);
}
/**
 * @tsplus static effect/core/stm/STM.Ops isInterruptException
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function isInterruptException(u: unknown): u is STMInterruptException;
export declare const STMRetryExceptionSym: unique symbol;
export type STMRetryExceptionSym = typeof STMRetryExceptionSym;
export declare class STMRetryException {
    readonly [STMRetryExceptionSym]: STMRetryExceptionSym;
}
/**
 * @tsplus static effect/core/stm/STM.Ops isRetryException
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function isRetryException(u: unknown): u is STMRetryException;
/**
 * Commits this transaction atomically.
 * @tsplus getter effect/core/stm/STM commit
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function commit<R, E, A>(self: STM<R, E, A>): Effect<R, E, A>;
/**
 * @tsplus static effect/core/stm/STM.Ops atomically
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function atomically<R, E, A>(self: STM<R, E, A>): Effect<R, E, A>;
/**
 * Executes the specified finalization transaction whether or
 * not this effect succeeds. Note that as with all STM transactions,
 * if the full transaction fails, everything will be rolled back.
 * @tsplus static effect/core/stm/STM.Aspects ensuring
 * @tsplus pipeable effect/core/stm/STM ensuring
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function ensuring<R1, B>(finalizer: STM<R1, never, B>): <R, E, A>(self: import("@effect/core/stm/STM/definition/base").STM<R, E, A>) => import("@effect/core/stm/STM/definition/base").STM<R1 | R, E, A>;
/**
 * Returns a value that models failure in the transaction.
 * @tsplus static effect/core/stm/STM.Ops fail
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function fail<E>(e: E): STM<never, E, never>;
/**
 * Returns an `STM` effect that succeeds with the specified value.
 * @tsplus static effect/core/stm/STM.Ops succeed
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function succeed<A>(a: A): STM<never, never, A>;
/**
 * Effectfully folds over the `STM` effect, handling both failure and
 * success.
 * @tsplus static effect/core/stm/STM.Aspects foldSTM
 * @tsplus pipeable effect/core/stm/STM foldSTM
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function foldSTM<E, R1, E1, A1, A, R2, E2, A2>(g: (e: E) => STM<R1, E1, A1>, f: (a: A) => STM<R2, E2, A2>): <R>(self: import("@effect/core/stm/STM/definition/base").STM<R, E, A>) => import("@effect/core/stm/STM/definition/base").STM<R1 | R2 | R, E1 | E2, A1 | A2>;
/**
 * Maps the value produced by the effect.
 * @tsplus static effect/core/stm/STM.Aspects map
 * @tsplus pipeable effect/core/stm/STM map
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function map<A, B>(f: (a: A) => B): <R, E>(self: import("@effect/core/stm/STM/definition/base").STM<R, E, A>) => import("@effect/core/stm/STM/definition/base").STM<R, E, B>;
/**
 * Sequentially zips this value with the specified one, discarding the first
 * element of the tuple.
 * @tsplus pipeable-operator effect/core/stm/STM >
 * @tsplus static effect/core/stm/STM.Aspects zipRight
 * @tsplus pipeable effect/core/stm/STM zipRight
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function zipRight<R1, E1, A1>(that: STM<R1, E1, A1>): <R, E, A>(self: import("@effect/core/stm/STM/definition/base").STM<R, E, A>) => import("@effect/core/stm/STM/definition/base").STM<R1 | R, E1 | E, A1>;
/**
 * Sequentially zips this value with the specified one, combining the values
 * using the specified combiner function.
 * @tsplus static effect/core/stm/STM.Aspects zipWith
 * @tsplus pipeable effect/core/stm/STM zipWith
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function zipWith<R1, E1, A1, A, A2>(that: STM<R1, E1, A1>, f: (a: A, b: A1) => A2): <R, E>(self: import("@effect/core/stm/STM/definition/base").STM<R, E, A>) => import("@effect/core/stm/STM/definition/base").STM<R1 | R, E1 | E, A2>;
/**
 * Returns an `STM` effect that succeeds with the specified value.
 * @tsplus static effect/core/stm/STM.Ops sync
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function sync<A>(a: LazyArg<A>): STM<never, never, A>;
/**
 * Recovers from all errors.
 * @tsplus static effect/core/stm/STM.Aspects catchAll
 * @tsplus pipeable effect/core/stm/STM catchAll
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function catchAll<E, R1, E1, B>(f: (e: E) => STM<R1, E1, B>): <R, A>(self: import("@effect/core/stm/STM/definition/base").STM<R, E, A>) => import("@effect/core/stm/STM/definition/base").STM<R1 | R, E1, B | A>;
/**
 * Feeds the value produced by this effect to the specified function,
 * and then runs the returned effect as well to produce its results.
 * @tsplus static effect/core/stm/STM.Aspects flatMap
 * @tsplus pipeable effect/core/stm/STM flatMap
 * @tsplus location "@effect/core/stm/STM/definition/primitives"
 */
export declare function flatMap<A, R1, E1, A2>(f: (a: A) => STM<R1, E1, A2>): <R, E>(self: import("@effect/core/stm/STM/definition/base").STM<R, E, A>) => import("@effect/core/stm/STM/definition/base").STM<R1 | R, E1 | E, A2>;
/**
 * @tsplus macro remove
 */
export declare function concreteSTM<R, E, A>(_: STM<R, E, A>): asserts _ is STMEffect<R, E, A> | STMOnFailure<R, unknown, E, A> | STMOnSuccess<R, E, unknown, A> | STMOnRetry<R, E, A, unknown, unknown, unknown> | STMSucceed<R, E, A> | STMSucceedNow<R, E, A> | STMProvide<unknown, R, E, A>;
export declare class STMDriver<R, E, A> {
    readonly self: STM<R, E, A>;
    readonly journal: Journal;
    readonly fiberId: FiberId;
    private yieldOpCount;
    private contStack;
    private envStack;
    constructor(self: STM<R, E, A>, journal: Journal, fiberId: FiberId, r0: Env<R>);
    private unwindStack;
    run(): TExit<E, A>;
}
export declare function tryCommit<R, E, A>(fiberId: FiberId, stm: STM<R, E, A>, state: AtomicReference<State<E, A>>, env: Env<R>, scheduler: Scheduler): TryCommit<E, A>;
export declare function tryCommitSync<R, E, A>(fiberId: FiberId, stm: STM<R, E, A>, env: Env<R>, scheduler: Scheduler): TryCommit<E, A>;
export declare function tryCommitAsync<R, E, A>(journal: Journal | undefined, fiberId: FiberId, stm: STM<R, E, A>, txnId: TxnId, state: AtomicReference<State<E, A>>, env: Env<R>, scheduler: Scheduler): (k: (_: Effect<R, E, A>) => unknown) => void;
export type Journal = Map<TRef<unknown>, Entry>;
export type JournalAnalysis = "I" | "RW" | "RO";
export type Todo = Lazy<unknown>;
/**
 * Creates a function that can reset the journal.
 */
export declare function prepareResetJournal(journal: Journal): Lazy<unknown>;
/**
 * Commits the journal.
 */
export declare function commitJournal(journal: Journal): void;
/**
 * Analyzes the journal, determining whether it is valid and whether it is
 * read only in a single pass. Note that information on whether the
 * journal is read only will only be accurate if the journal is valid, due
 * to short-circuiting that occurs on an invalid journal.
 */
export declare function analyzeJournal(journal: Journal): JournalAnalysis;
export declare const emptyTodoMap: import("@tsplus/stdlib/collections/HashMap").HashMap<number, Todo>;
/**
 * Atomically collects and clears all the todos from any `TRef` that
 * participated in the transaction.
 */
export declare function collectTodos(journal: Journal): Map<TxnId, Todo>;
/**
 * Executes the todos in the current thread, sequentially.
 */
export declare function execTodos(todos: Map<TxnId, Todo>): void;
/**
 * Runs all the todos.
 */
export declare function completeTodos<E, A>(exit: Exit<E, A>, journal: Journal, scheduler: Scheduler): TryCommit<E, A>;
/**
 * For the given transaction id, adds the specified todo effect to all
 * `TRef` values.
 */
export declare function addTodo(txnId: TxnId, journal: Journal, todoEffect: Todo): boolean;
/**
 * Finds all the new todo targets that are not already tracked in the
 * `oldJournal`.
 */
export declare function untrackedTodoTargets(oldJournal: Journal, newJournal: Journal): Journal;
/**
 * Determines if the journal is valid.
 */
export declare function isValid(journal: Journal): boolean;
/**
 * Determines if the journal is invalid.
 */
export declare function isInvalid(journal: Journal): boolean;
//# sourceMappingURL=primitives.d.ts.map