import type { Budget } from "./budget.js";
import type { GeneratorChannel } from "./generator.js";
import { type RegexPattern } from "./regex/parse.js";
declare const sandboxClosureBrand: unique symbol;
declare const sandboxGeneratorBrand: unique symbol;
declare const sandboxMapBrand: unique symbol;
declare const sandboxPromiseBrand: unique symbol;
declare const sandboxRegexBrand: unique symbol;
declare const sandboxRegexPattern: unique symbol;
declare const sandboxSetBrand: unique symbol;
declare const sandboxRetainedValues: unique symbol;
export type SandboxPrimitive = string | number | boolean | null | undefined;
export type SandboxValue = SandboxPrimitive | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
export type SandboxObject = {
    [key: string]: SandboxValue;
};
export type SandboxArray = SandboxValue[];
export type SandboxMap = {
    readonly kind: "map";
    readonly entries: Map<SandboxValue, SandboxValue>;
    readonly [sandboxMapBrand]: true;
};
export type SandboxSet = {
    readonly kind: "set";
    readonly values: Set<SandboxValue>;
    readonly [sandboxSetBrand]: true;
};
export type SandboxRegex = {
    readonly kind: "regex";
    readonly source: string;
    readonly flags: string;
    lastIndex: number;
    readonly [sandboxRegexBrand]: true;
    readonly [sandboxRegexPattern]: RegexPattern;
};
export type SandboxCallContext = {
    readonly span?: {
        readonly end: {
            readonly column: number;
            readonly line: number;
            readonly offset: number;
        };
        readonly start: {
            readonly column: number;
            readonly line: number;
            readonly offset: number;
        };
    };
    readonly stack: readonly string[];
    readonly thisValue: SandboxValue;
};
export type SandboxClosure = {
    readonly async?: true;
    readonly kind: "fn";
    readonly name?: string;
    readonly properties?: SandboxObject;
    readonly call: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
    readonly construct?: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
    readonly [sandboxClosureBrand]: true;
    readonly [sandboxRetainedValues]?: () => Iterable<SandboxValue>;
};
export type SandboxPromise = {
    readonly kind: "promise";
    readonly promise: Promise<SandboxValue>;
    readonly hostCall?: import("./host-call.js").HostCallRecord;
    readonly hostCallJournal?: import("./host-call.js").HostCallJournal;
    readonly span?: SandboxCallContext["span"];
    readonly [sandboxPromiseBrand]: true;
};
export type SandboxGenerator = {
    readonly kind: "generator";
    state: "start" | "running" | "suspended" | "done";
    readonly channel: GeneratorChannel;
    readonly astNodeId?: number;
    readonly capturedScopeId?: number | string;
    readonly [sandboxGeneratorBrand]: true;
};
type CopyFromSandboxOptions = {
    wrapClosure?: (value: SandboxClosure) => unknown;
};
export declare function createSandboxClosure(input: {
    async?: boolean;
    call: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
    construct?: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
    name?: string;
    properties?: SandboxObject;
    retainedValues?: () => Iterable<SandboxValue>;
}): SandboxClosure;
export declare function createSandboxPromise(promise: Promise<SandboxValue>, metadata?: {
    hostCall?: import("./host-call.js").HostCallRecord;
    hostCallJournal?: import("./host-call.js").HostCallJournal;
    span?: SandboxCallContext["span"];
}): SandboxPromise;
export declare function createSandboxGenerator(channel: GeneratorChannel, metadata?: {
    astNodeId: number;
    capturedScopeId: number | string;
} | undefined): SandboxGenerator;
export declare function createSandboxMap(entries?: Iterable<readonly [SandboxValue, SandboxValue]>): SandboxMap;
export declare function createSandboxSet(values?: Iterable<SandboxValue>): SandboxSet;
export declare function createSandboxRegex(source: string, flags?: string, lastIndex?: number): SandboxRegex;
export declare function getSandboxRegexPattern(regex: SandboxRegex): RegexPattern;
export declare function isSandboxClosure(value: unknown): value is SandboxClosure;
export declare function isSandboxMap(value: unknown): value is SandboxMap;
export declare function isSandboxPromise(value: unknown): value is SandboxPromise;
export declare function isSandboxSet(value: unknown): value is SandboxSet;
export declare function isSandboxGenerator(value: unknown): value is SandboxGenerator;
export declare function isSandboxRegex(value: unknown): value is SandboxRegex;
export declare function deepCopyToSandbox(value: unknown): SandboxValue;
export declare function cloneSandboxValue(value: SandboxValue): SandboxValue;
export declare function allocateProducedSandboxValue(value: SandboxValue, budget: Budget): SandboxValue;
export declare function measureSandboxData(values: Iterable<unknown>): number;
export declare function deepCopyFromSandbox(value: SandboxPromise, options?: CopyFromSandboxOptions): Promise<unknown>;
export declare function deepCopyFromSandbox(value: SandboxValue, options?: CopyFromSandboxOptions): unknown;
export {};