import type { Either } from "../../Either";
import * as E from "../../Either";
import { AtomicNumber, AtomicReference } from "../../support";
import type { IO } from "../Task";
/**
 * Represents a key in a scope, which is associated with a single finalizer.
 */
export declare class Key {
   /**
    * Attempts to remove the finalizer associated with this key from the
    * scope. The returned effect will succeed with a boolean, which indicates
    * whether the attempt was successful. A value of `true` indicates the
    * finalizer will not be executed, while a value of `false` indicates the
    * finalizer was already executed
    */
   remove: IO<boolean>;
   constructor(remove?: IO<boolean>);
   setRemove(remove: IO<boolean>): void;
}
/**
 * Represent Common Ops between Global | Local<A>
 */
export interface CommonScope<A> {
   /**
    * Determines if the scope is closed at the instant the effect executes.
    * Returns a task that will succeed with `true` if the scope is closed,
    * and `false` otherwise.
    */
   readonly closed: IO<boolean>;
   /**
    * Prevents a previously added finalizer from being executed when the scope
    * is closed. The returned effect will succeed with `true` if the finalizer
    * will not be run by this scope, and `false` otherwise.
    */
   readonly deny: (key: Key) => IO<boolean>;
   /**
    * Determines if the scope is empty (has no finalizers) at the instant the
    * effect executes. The returned effect will succeed with `true` if the scope
    * is empty, and `false` otherwise.
    */
   readonly empty: IO<boolean>;
   /**
    * Adds a finalizer to the scope. If successful, this ensures that when the
    * scope exits, the finalizer will be run
    *
    * The returned effect will succeed with a key ifthe finalizer was added
    * to the scope, and `None` if the scope is already closed.
    */
   readonly ensure: (finalizer: (a: A) => IO<any>) => IO<Either<A, Key>>;
   /**
    * Extends the specified scope so that it will not be closed until this
    * scope is closed. Note that extending a scope into the global scope
    * will result in the scope *never* being closed!
    *
    * Scope extension does not result in changes to the scope contract: open
    * scopes must *always* be closed.
    */
   readonly extend: (that: Scope<any>) => IO<boolean>;
   /**
    * Determines if the scope is open at the moment the effect is executed.
    * Returns a task that will succeed with `true` if the scope is open,
    * and `false` otherwise.
    */
   readonly open: IO<boolean>;
   /**
    * Determines if the scope has been released at the moment the effect is
    * executed. A scope can be closed yet unreleased, if it has been
    * extended by another scope which is not yet released.
    */
   readonly released: IO<boolean>;
   readonly unsafeEnsure: (finalizer: (_: A) => IO<any>) => Either<A, Key>;
   readonly unsafeExtend: (that: Scope<any>) => boolean;
   readonly unsafeDeny: (key: Key) => boolean;
}
/**
 * A `Scope<A>` is a value that allows adding finalizers identified by a key.
 * Scopes are closed with a value of type `A`, which is provided to all the
 * finalizers when the scope is released.
 *
 * For safety reasons, this interface has no method to close a scope. Rather,
 * an open scope may be required with `makeScope`, which returns a function
 * that can close a scope. This allows scopes to be safely passed around
 * without fear they will be accidentally closed.
 */
export declare type Scope<A> = GlobalScope | LocalScope<A>;
/**
 * The global scope, which is entirely stateless. Finalizers added to the
 * global scope will never be executed (nor kept in memory).
 */
export declare class GlobalScope implements CommonScope<never> {
   readonly _tag = "Global";
   constructor();
   private unsafeEnsureResult;
   private ensureResult;
   get closed(): IO<boolean>;
   deny(_key: Key): IO<boolean>;
   get empty(): IO<boolean>;
   ensure(_finalizer: (a: never) => IO<any>): IO<E.Either<never, Key>>;
   extend(that: Scope<any>): IO<boolean>;
   get open(): IO<boolean>;
   get released(): IO<boolean>;
   unsafeEnsure(_finalizer: (_: never) => IO<any>): E.Either<never, Key>;
   unsafeExtend(that: Scope<any>): boolean;
   unsafeDeny(): boolean;
}
export declare class OrderedFinalizer {
   readonly order: number;
   readonly finalizer: (_: any) => IO<any>;
   constructor(order: number, finalizer: (_: any) => IO<any>);
}
export declare class LocalScope<A> implements CommonScope<A> {
   readonly finalizerCount: AtomicNumber;
   readonly exitValue: AtomicReference<A | null>;
   readonly references: AtomicNumber;
   readonly finalizers: Map<Key, OrderedFinalizer>;
   readonly _tag = "Local";
   constructor(
      finalizerCount: AtomicNumber,
      exitValue: AtomicReference<A | null>,
      references: AtomicNumber,
      finalizers: Map<Key, OrderedFinalizer>
   );
   get closed(): IO<boolean>;
   get open(): IO<boolean>;
   deny(key: Key): IO<boolean>;
   get empty(): IO<boolean>;
   ensure(finalizer: (a: A) => IO<any>): IO<E.Either<A, Key>>;
   extend(that: Scope<any>): IO<boolean>;
   get released(): IO<boolean>;
   unsafeExtend(that: Scope<any>): boolean;
   get release(): IO<boolean>;
   unsafeReleased(): boolean;
   unsafeEnsure(finalizer: (_: A) => IO<any>): E.Either<A, Key>;
   unsafeAddRef(): boolean;
   get unsafeClosed(): boolean;
   unsafeDeny(key: Key): boolean;
   unsafeClose(a: A): IO<any> | null;
   unsafeRelease(): IO<any> | null;
   get unsafeEmpty(): boolean;
}
/**
 * The global scope, which is entirely stateless. Finalizers added to the
 * global scope will never be executed (nor kept in memory).
 */
export declare const globalScope: GlobalScope;
/**
 * A tuple that contains an open scope, together with a function that closes
 * the scope.
 */
export declare class Open<A> {
   readonly close: (_: A) => IO<boolean>;
   readonly scope: LocalScope<A>;
   constructor(close: (_: A) => IO<boolean>, scope: LocalScope<A>);
}
export declare const unsafeMakeScope: <A>() => Open<A>;
export declare const makeScope: <A>() => IO<Open<A>>;
//# sourceMappingURL=Scope.d.ts.map