export declare const enter: unique symbol;
export declare const exit: unique symbol;
type Result<T, E = unknown> = {
    value: T;
} | {
    exception: E;
};
export declare class EnterException {
    exception: unknown;
    constructor(exception: unknown);
}
export declare class ExitException<TReturn> {
    exception: unknown;
    result: Result<TReturn>;
    constructor(exception: unknown, result: Result<TReturn>);
}
/**
 * An object implementing the `Context` interface has some notion of
 * "being entered" and always eventually "being exited". It should be used
 * together with the `within` function to enclose a function with a context.
 *
 * A "handle" is an object that can only assumed valid while within the
 * context. It should not be used after the context has exited and doing
 * so should be treated as undefined behavior.
 *
 * The `within` function will:
 *  - call the `enter` method exactly once.
 *  - call the `exit` exactly once and only after `enter` has been called.
 */
export interface Context<THandle> {
    [enter]: () => MaybePromise<THandle>;
    [exit]?: (handle: THandle) => MaybePromise<void>;
}
type ContextResult<TEnterResult extends MaybePromise<any>, TFnResult extends MaybePromise<any>, TExitResult extends MaybePromise<void>> = TFnResult extends PromiseLike<any> ? TFnResult : TEnterResult extends PromiseLike<any> ? PromiseLike<TFnResult> : TExitResult extends PromiseLike<any> ? PromiseLike<TFnResult> : TFnResult;
type MaybePromise<T> = T | PromiseLike<T>;
type Resolve<T extends MaybePromise<any>> = T extends MaybePromise<infer U> ? U : T;
export declare function within<TEnterResult extends MaybePromise<any>, TFnResult extends MaybePromise<any>, TExitResult extends MaybePromise<void> = void>(context: {
    [enter]: () => TEnterResult;
    [exit]?: (handler: Resolve<TEnterResult>) => TExitResult;
}, fn: (handler: Resolve<TEnterResult>) => TFnResult): ContextResult<TEnterResult, TFnResult, TExitResult>;
export {};
//# sourceMappingURL=context.d.ts.map