import type { Effect } from "effect";
import type { SafeObject } from "../tool-runtime.js";
import type { CodeModePromise, CodeModeRegExp, CodeModeURL } from "../values.js";
export type SourcePosition = {
    line: number;
    column: number;
};
export type SourceLocation = {
    start: SourcePosition;
    end: SourcePosition;
};
export type AstNode = {
    type: string;
    loc?: SourceLocation;
    [key: string]: unknown;
};
export type ProgramNode = AstNode & {
    type: "Program";
    body: Array<AstNode>;
};
export type Binding = {
    mutable: boolean;
    value: unknown;
    initialized?: boolean;
};
export type StatementResult = {
    kind: "none";
} | {
    kind: "return";
    value: unknown;
} | {
    kind: "break";
    label?: string;
} | {
    kind: "continue";
    label?: string;
};
export type MemberReference = {
    target: SafeObject | Array<unknown> | CodeModeRegExp | CodeModeURL;
    key: PropertyKey;
};
export declare class CodeModeFunction {
    readonly parameters: ReadonlyArray<AstNode>;
    readonly body: AstNode;
    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
    readonly async: boolean;
    readonly generator: boolean;
    constructor(parameters: ReadonlyArray<AstNode>, body: AstNode, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
}
export type GeneratorRequestKind = "next" | "return" | "throw";
export declare class CodeModeGenerator {
    readonly asynchronous: boolean;
    readonly request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>;
    constructor(asynchronous: boolean, request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>);
}
export declare class GeneratorMethodReference {
    readonly generator: CodeModeGenerator;
    readonly kind: GeneratorRequestKind | "iterator";
    constructor(generator: CodeModeGenerator, kind: GeneratorRequestKind | "iterator");
}
export declare class IntrinsicReference {
    readonly receiver: unknown;
    readonly name: string;
    constructor(receiver: unknown, name: string);
}
export declare class ComputedValue {
    readonly value: unknown;
    constructor(value: unknown);
}
export declare class PromiseNamespace {
}
export declare class SymbolNamespace {
}
export declare const AsyncIteratorSymbol: unique symbol;
export declare const IteratorSymbol: unique symbol;
export declare const IteratorSymbols: readonly [typeof AsyncIteratorSymbol, typeof IteratorSymbol];
export type PromiseMethodName = "all" | "allSettled" | "race" | "any" | "resolve" | "reject";
export declare class PromiseMethodReference {
    readonly name: PromiseMethodName;
    constructor(name: PromiseMethodName);
}
export type PromiseInstanceMethodName = "then" | "catch" | "finally";
export declare class PromiseInstanceMethodReference {
    readonly promise: CodeModePromise;
    readonly name: PromiseInstanceMethodName;
    constructor(promise: CodeModePromise, name: PromiseInstanceMethodName);
}
export declare class PromiseCapabilityFunction {
    readonly settle: (value: unknown) => void;
    constructor(settle: (value: unknown) => void);
}
export type GlobalNamespaceName = "Object" | "Math" | "JSON" | "Array" | "console" | "Date" | "RegExp" | "Map" | "Set" | "URL" | "URLSearchParams";
export declare class GlobalNamespace {
    readonly name: GlobalNamespaceName;
    constructor(name: GlobalNamespaceName);
}
export declare class GlobalMethodReference {
    readonly namespace: Exclude<GlobalNamespaceName, "JSON"> | "Number" | "String";
    readonly name: string;
    constructor(namespace: Exclude<GlobalNamespaceName, "JSON"> | "Number" | "String", name: string);
}
export declare class JsonMethodReference {
    readonly name: "parse" | "stringify";
    constructor(name: "parse" | "stringify");
}
export declare class CoercionFunction {
    readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
    constructor(name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN");
}
export declare class UriFunction {
    readonly name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent";
    constructor(name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent");
}
export declare class SearchFunction {
}
export declare class ProgramThrow {
    readonly value: unknown;
    constructor(value: unknown);
}
export declare class GeneratorReturn {
    readonly value: unknown;
    constructor(value: unknown);
}
export declare class ErrorConstructorReference {
    readonly name: string;
    constructor(name: string);
}
export type DiagnosticKind = "ParseError" | "UnsupportedSyntax" | "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded" | "TimeoutExceeded" | "ToolFailure" | "ExecutionFailure";
export declare const OptionalShortCircuit: unique symbol;
export declare const supportedSyntaxMessage = "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction.";
export declare class InterpreterRuntimeError extends Error {
    readonly kind: DiagnosticKind;
    readonly suggestions?: ReadonlyArray<string> | undefined;
    readonly node?: AstNode;
    errorName: string;
    constructor(message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined);
    as(errorName: string): this;
}
export declare const unsupportedSyntax: (kind: string, node: AstNode) => InterpreterRuntimeError;
export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
export declare const asNode: (value: unknown, context: string) => AstNode;
export declare const getArray: (node: AstNode, key: string) => Array<unknown>;
export declare const getString: (node: AstNode, key: string) => string;
export declare const getBoolean: (node: AstNode, key: string) => boolean;
export declare const getOptionalNode: (node: AstNode, key: string) => AstNode | undefined;
export declare const getNode: (node: AstNode, key: string) => AstNode;
export declare const sourceLocation: (node: AstNode) => {
    readonly line: number;
    readonly column: number;
};
export declare const formatLocation: (node?: AstNode) => string;