import { type GCMarker } from './host-defined/engine.mts';
import { JSStringValue, Value } from './value.mts';
import type { Evaluator, ValueEvaluator } from './evaluator.mts';
type NormalCompletionInit<T> = Pick<NormalCompletion<T>, 'Type' | 'Value' | 'Target'>;
type BreakCompletionInit = Pick<BreakCompletion, 'Type' | 'Value' | 'Target'>;
type ContinueCompletionInit = Pick<ContinueCompletion, 'Type' | 'Value' | 'Target'>;
type ReturnCompletionInit = Pick<ReturnCompletion, 'Type' | 'Value' | 'Target'>;
type ThrowCompletionInit = Pick<ThrowCompletion, 'Type' | 'Value' | 'Target'>;
type AbruptCompletionInit = BreakCompletionInit | ContinueCompletionInit | ReturnCompletionInit | ThrowCompletionInit;
type CompletionInit<T> = NormalCompletionInit<T> | AbruptCompletionInit;
declare class CompletionImpl<const T> {
    readonly Type: 'normal' | 'break' | 'continue' | 'return' | 'throw';
    readonly Value: T | Value;
    readonly Target: JSStringValue | undefined;
    constructor(init: CompletionInit<T>);
    mark(m: GCMarker): void;
}
/** https://tc39.es/ecma262/#sec-completion-record-specification-type */
export type Completion<T> = NormalCompletion<T> | AbruptCompletion;
/**
 * A NON-SPEC shorthand to notate "returns either a normal completion containing an ECMAScript language value or a throw completion".
 */
export type ValueCompletion<T extends Value = Value> = T | NormalCompletion<T> | ThrowCompletion;
export { type ValueEvaluator } from './evaluator.mts';
/**
 * A NON-SPEC shorthand to notate "returns either a normal completion containing ... or a throw completion".
 *
 * If the T is an ECMAScript language value, use ExpressionCompletion<T>.
 */
export type PlainCompletion<T> = T | NormalCompletion<T> | ThrowCompletion;
export type YieldCompletion = NormalCompletion<Value> | ThrowCompletion | ReturnCompletion;
/** https://tc39.es/ecma262/#sec-completion-ao */
export declare const Completion: {
    /** https://tc39.es/ecma262/#sec-completion-ao */
    <T extends Completion<unknown>>(completionRecord: T): T;
    /** https://tc39.es/ecma262/#sec-completion-record-specification-type */
    new <const T>(completion: {
        Type: 'normal';
        Value: T;
        Target: undefined;
    }): NormalCompletion<T>;
    new (completion: {
        Type: 'break';
        Value: void;
        Target: JSStringValue | undefined;
    }): BreakCompletion;
    new (completion: {
        Type: 'continue';
        Value: void;
        Target: JSStringValue | undefined;
    }): ContinueCompletion;
    new (completion: {
        Type: 'return';
        Value: Value;
        Target: undefined;
    }): ReturnCompletion;
    new (completion: {
        Type: 'throw';
        Value: Value;
        Target: undefined;
    }): ThrowCompletion;
    readonly prototype: CompletionImpl<unknown>;
};
declare class NormalCompletionImpl<const T> extends CompletionImpl<T> {
    readonly Type: 'normal';
    readonly Value: T;
    readonly Target: undefined;
    private constructor();
}
/** https://tc39.es/ecma262/#sec-completion-record-specification-type */
export type NormalCompletion<T> = NormalCompletionImpl<T>;
/** https://tc39.es/ecma262/#sec-normalcompletion */
export declare const NormalCompletion: typeof NormalCompletionImpl & {
    /** https://tc39.es/ecma262/#sec-normalcompletion */
    <const T>(value: T): NormalCompletion<T>;
};
/** https://tc39.es/ecma262/#sec-completion-record-specification-type */
export type AbruptCompletion = ThrowCompletion | ReturnCompletion | BreakCompletion | ContinueCompletion;
/** https://tc39.es/ecma262/#sec-completion-record-specification-type */
export declare const AbruptCompletion: abstract new <const T>(init: AbruptCompletionInit) => {
    readonly Type: 'break' | 'continue' | 'return' | 'throw';
    readonly Value: T | Value;
    readonly Target: JSStringValue | undefined;
    mark(m: GCMarker): void;
};
/** https://tc39.es/ecma262/#sec-completion-record-specification-type */
export declare class BreakCompletion extends AbruptCompletion<void> {
    readonly Type: 'break';
    readonly Value: void;
    private constructor();
}
/** https://tc39.es/ecma262/#sec-completion-record-specification-type */
export declare class ContinueCompletion extends AbruptCompletion<void> {
    readonly Type: 'continue';
    readonly Value: void;
    readonly Target: JSStringValue | undefined;
    private constructor();
}
declare class ReturnCompletion_ extends AbruptCompletion<Value> {
    readonly Type: 'return';
    readonly Value: Value;
    readonly Target: undefined;
    private constructor();
}
/** https://tc39.es/ecma262/#sec-completion-record-specification-type */
export type ReturnCompletion = ReturnCompletion_;
/** https://tc39.es/ecma262/#sec-throwcompletion */
export declare const ReturnCompletion: typeof ReturnCompletion_ & {
    /** https://tc39.es/ecma262/#sec-throwcompletion */
    <T extends Value = Value>(value: T): ThrowCompletion<T>;
};
declare class ThrowCompletion_<T extends Value = Value> extends AbruptCompletion<T> {
    readonly Type: 'throw';
    readonly Value: T;
    readonly Target: undefined;
    readonly stack: Error | undefined;
    private constructor();
}
/** https://tc39.es/ecma262/#sec-completion-record-specification-type */
export type ThrowCompletion<T extends Value = Value> = ThrowCompletion_<T>;
/** https://tc39.es/ecma262/#sec-throwcompletion */
export declare const ThrowCompletion: typeof ThrowCompletion_ & {
    /** https://tc39.es/ecma262/#sec-throwcompletion */
    <T extends Value = Value>(value: T): ThrowCompletion<T>;
};
/** https://tc39.es/ecma262/#sec-updateempty */
export type UpdateEmpty<T extends Completion<unknown>, U> = T extends NormalCompletion<infer V> ? NormalCompletion<V extends undefined ? U : V> : T extends BreakCompletion ? BreakCompletion : T extends ContinueCompletion ? ContinueCompletion : T extends AbruptCompletion ? T : T extends ReturnCompletion ? T : never;
/** https://tc39.es/ecma262/#sec-updateempty */
export declare function UpdateEmpty<C extends Completion<unknown>, const T>(completionRecord: C, value: T): UpdateEmpty<C, T>;
/** https://tc39.es/ecma262/#sec-returnifabrupt */
export type Q<T> = T extends NormalCompletion<infer V> ? V : T extends AbruptCompletion ? never : T;
export declare function isEvaluator(value: unknown): value is Evaluator<unknown>;
export declare function unwrapCompletion<const T>(completion: T | Evaluator<T>): Q<T>;
/**
 * This is a util for code that cannot use Q() or X() marco to emulate this behaviour.
 *
 * @example
 * import { evalQ } from '...'
 * evalQ((Q) => {
 *     let val = Q(operation);
 * });
 */
export declare function evalQ<T>(callback: (q: typeof Q, x: typeof X) => Promise<T>): Promise<NormalCompletion<T> | ThrowCompletion>;
export declare function evalQ<T>(callback: (q: typeof Q, x: typeof X) => T): NormalCompletion<T> | ThrowCompletion;
export type EnsureCompletion<T> = EnsureCompletionWorker<T, T>;
type EnsureCompletionWorker<T, _T> = T extends Completion<unknown> ? T : NormalCompletion<Exclude<_T, PlainCompletion<unknown>>>;
/** https://tc39.es/ecma262/#sec-implicit-normal-completion */
export declare function EnsureCompletion(val: Value): NormalCompletion<Value>;
export declare function EnsureCompletion<const T>(val: T): EnsureCompletion<T>;
export declare function ValueOfNormalCompletion<T>(value: NormalCompletion<T> | T): T;
export declare function Await(value: Value): ValueEvaluator;
//# sourceMappingURL=completion.d.mts.map