import type { AliasNameTable, BuiltInFunctionInputSignature, BuiltInFunctionSignature, ExpressionBoundaryValue, NameEntry, NodeBuiltInFunction, NodeExpr, NodeInput, NodeFunctionDefinition, RuntimeExpressionValue } from './AST';
import type { ClassMethodDefinition as ClassMethodDefinitionBase } from './ClassMember';
import { CharString } from './CharString';
import { type ComplexType } from './Complex';
import { MultiArray } from './MultiArray';
import { ClassDefinition } from './ClassDefinition';
import { ClassInstance } from './ClassInstance';
import { ClassBoundMethod } from './ClassBoundMethod';
import { ClassStaticMethod } from './ClassStaticMethod';
import { ClassEmptyMethod } from './ClassEmptyMethod';
import type { BinaryMathOperation, KeyOfTypeOfMathOperation, UnaryMathOperation } from './MathOperation';
import { Scope } from './Scope';
import { CallFrame } from './CallFrame';
import { type Callable } from './Callable';
import type { CallArgumentValue } from './FunctionCall';
type ClassMethodDefinition = ClassMethodDefinitionBase<ClassDefinition>;
/**
 * Interpreter services used by `Context`.
 *
 * Keeping this as a narrow structural interface avoids a hard cycle between the
 * execution context and the full interpreter implementation while still letting
 * the context call back into parsing/evaluation-sensitive operations.
 */
interface ContextInterpreter {
    /** Whether debug tracing is enabled for call/index dispatch. */
    debug: boolean;
    /** Evaluate one AST/runtime node in a scope. */
    Evaluator(tree: NodeInput, scope?: Scope): NodeInput;
    /** Return parameters backed exclusively by name-value declarations. */
    getFunctionNameValueParameters(func: NodeFunctionDefinition): Set<string>;
    /** Split call-site expressions into positional and name-value groups. */
    splitFunctionCallNameValueArguments(func: NodeFunctionDefinition, args: CallArgumentValue[]): {
        positional: CallArgumentValue[];
        named: Map<string, CallArgumentValue>;
    };
    /** Return default input expressions keyed by parameter name. */
    getFunctionInputArgumentDefaults(func: NodeFunctionDefinition): Map<string, NodeExpr>;
    /** Return the `arguments (Output,Repeating)` output name, when present. */
    getFunctionOutputRepeatingName(func: NodeFunctionDefinition): string | undefined;
    /** Bind evaluated name-value arguments into a function call scope. */
    bindFunctionNameValueArguments(func: NodeFunctionDefinition, scope: Scope, values: Map<string, ExpressionBoundaryValue>): void;
    /** Preprocess imports that apply to an entire script/function scope. */
    applyScopedImports(tree: NodeInput, scope: Scope): void;
    /** Register nested functions visible from a function body. */
    registerNestedFunctions(func: NodeFunctionDefinition, scope: Scope): void;
    /** Validate input `arguments` blocks after inputs are bound. */
    validateFunctionInputArguments(func: NodeFunctionDefinition, scope: Scope): void;
    /** Validate `arguments (Repeating)` declarations against `varargin`. */
    validateFunctionRepeatingArguments(func: NodeFunctionDefinition, scope: Scope, values: ExpressionBoundaryValue[]): void;
    /** Validate output `arguments` blocks after the body executes. */
    validateFunctionOutputArguments(func: NodeFunctionDefinition, scope: Scope, requestedOutputCount: number, outputMask?: boolean[]): void;
    /** Validate property defaults for a newly instantiated class object. */
    validateClassInstancePropertyDefaults(instance: ClassInstance, scope: Scope): void;
    /** Resolve a function source through the configured function provider API. */
    loadFunctionDefinition(name: string, scope: Scope): NodeFunctionDefinition | undefined;
    /** Resolve a class source through the configured class provider API. */
    loadClassDefinition(name: string, scope: Scope): ClassDefinition | undefined;
    /** Resolve a class method source for a prototype declared in a classdef block. */
    loadClassMethodDefinition(className: string, methodName: string, scope: Scope): NodeFunctionDefinition | undefined;
    /** Resolve a static class method selected by qualified name or visible imports. */
    resolveStaticMethod(name: string, scope: Scope): ClassStaticMethod | undefined;
    /** Dispatch a functional operator call through class overload semantics, when applicable. */
    callFunctionalOperatorOverload(node: NodeBuiltInFunction, args: CallArgumentValue[], parent: NodeInput): NodeExpr | undefined;
    /** Convert object values used as native array indices through `subsindex`. */
    convertIndexArgument(value: NodeInput, parent: NodeInput): NodeInput;
}
/**
 * Kinds of MATLAB/Octave symbols that can be resolved from a name.
 */
type SymbolResolutionKind = 'variable' | 'class' | 'function' | 'builtin' | 'script' | 'directory';
/**
 * Source tier that produced a resolved symbol.
 */
type SymbolResolutionSource = 'local' | 'import' | 'builtin';
/**
 * Options that tune name lookup while keeping the default MATLAB/Octave
 * precedence intact.
 */
type SymbolResolutionOptions = {
    /** Whether variable bindings should be considered. */
    variables?: boolean;
    /** Whether class definitions should be considered. */
    classes?: boolean;
    /** Whether class source providers may be loaded as part of class lookup. */
    loadClasses?: boolean;
    /** Whether function source providers may be loaded as part of function lookup. */
    loadFunctions?: boolean;
    /** Whether user functions and built-ins should be considered. */
    functions?: boolean;
    /** Whether imported simple-name candidates may be considered. */
    imports?: boolean;
};
/**
 * Structured result for one resolved name.
 */
type SymbolResolution = {
    /** Symbol category selected by name precedence. */
    kind: SymbolResolutionKind;
    /** Name requested by the caller. */
    name: string;
    /** Canonical name actually resolved after aliases/imports. */
    resolvedName: string;
    /** Lookup tier that produced the result. */
    source: SymbolResolutionSource;
    /** Variable entry when {@link kind} is `variable`. */
    entry?: NameEntry;
    /** Class definition when {@link kind} is `class`. */
    classDefinition?: ClassDefinition;
    /** Function node when {@link kind} is `function` or `builtin`. */
    functionDefinition?: NodeFunctionDefinition | NodeBuiltInFunction;
    /** Virtual `.m` source identity when lookup only materialized source metadata. */
    sourceName?: string;
};
/**
 * Kinds of call/index dispatch selected after a callee expression is evaluated.
 */
type CallDispatchKind = 'callable' | 'bound-method' | 'bound-method-array' | 'static-method' | 'empty-method' | 'constructor' | 'functional-class-method' | 'undefined-function' | 'indexing';
/**
 * Structured call/index dispatch decision.
 */
type CallDispatch = {
    kind: 'callable';
    callable: Callable;
    expr: NodeExpr;
} | {
    kind: 'bound-method';
    expr: ClassBoundMethod;
} | {
    kind: 'bound-method-array';
    expr: MultiArray;
} | {
    kind: 'static-method';
    expr: ClassStaticMethod;
} | {
    kind: 'empty-method';
    expr: ClassEmptyMethod;
} | {
    kind: 'constructor';
    expr: ClassDefinition;
} | {
    kind: 'functional-class-method';
    expr: NodeExpr;
    functionalName: string;
    functionalReceiver: NodeInput;
} | {
    kind: 'undefined-function';
    expr: NodeExpr;
    functionalName: string;
} | {
    kind: 'indexing';
    expr: NodeExpr;
};
/**
 * Internal control-flow signal used to leave a function body on `return`.
 */
declare class ReturnSignal extends Error {
    constructor();
}
/**
 * Internal control-flow signal used to leave loop bodies on `break`.
 */
declare class BreakSignal extends Error {
    constructor();
}
/**
 * Internal control-flow signal used to continue loop bodies on `continue`.
 */
declare class ContinueSignal extends Error {
    constructor();
}
/**
 * Execution context for MathJSLab evaluation.
 *
 * `Context` owns the call stack, global workspace, built-in table, arity state,
 * comma-separated-list expansion state, class access stack, and MATLAB-like
 * workspace helpers. The interpreter owns AST traversal and delegates runtime
 * mechanics here so function calls, built-ins, class dispatch, and diagnostics
 * share one consistent state model.
 */
declare class Context {
    /**
     * Interpreter instance associated to this context.
     */
    interpreter?: ContextInterpreter | undefined;
    /**
     * Global scope.
     */
    globalScope?: Scope | undefined;
    /**
     * Built-in function table.
     */
    builtInFunctionTable: Record<string, NodeBuiltInFunction>;
    /**
     * Whether assignments may keep unresolved identifiers for later resolution.
     */
    allowForwardReference: boolean;
    /**
     * Names declared as global in the current context.
     */
    globalNameSet: Set<string>;
    /**
     * Global names initialized by Octave-style `global name = value`
     * declarations during this context lifetime.
     */
    globalInitializedNameSet: Set<string>;
    /**
     * Assignment targets whose right-hand side is currently being evaluated.
     *
     * This stack lets undefined-reference handling distinguish a local
     * forward reference from a dependency cycle such as `A -> B -> A`.
     */
    private forwardReferenceTargetStack;
    /**
     * Requested output counts for expressions currently being evaluated.
     */
    private requestedOutputCountStack;
    /**
     * Per-output request masks for expressions currently being evaluated.
     */
    private requestedOutputMaskStack;
    /**
     * Whether the current evaluation context should expand comma-separated lists.
     */
    private commaListExpansionStack;
    /**
     * Classes whose method bodies are currently executing.
     */
    private classAccessStack;
    /** Built-ins that MATLAB/Octave users commonly invoke without parentheses. */
    private static readonly bareZeroArgumentBuiltins;
    /**
     * Built-in function names that are also operator method names.
     *
     * Direct calls such as `lt(a,b)` and handles such as `f = @plus; f(a,b)`
     * must give class operands the same overload opportunity as symbolic
     * operators (`a < b`, `a + b`). Keeping the list here avoids importing
     * `MathOperation` as a runtime value into `Context`.
     */
    private static readonly operatorFunctionNames;
    /**
     * Built-ins whose MATLAB class implementations are ordinary instance
     * methods when the first argument is an object.
     */
    private static readonly classBuiltinMethodFunctionNames;
    /**
     * Function call stack.
     */
    callStack: CallFrame[];
    /**
     * Reset the execution context to a provided scope/stack or to a fresh global state.
     *
     * @param globalScope Optional global scope to install.
     * @param callStack Optional call stack to install.
     */
    loadContext(globalScope?: Scope, callStack?: CallFrame[]): void;
    /**
     * Private constructor (only used by `create` static method).
     * @param globalScope Optional global scope reference.
     * @param callStack Optional function call stack reference.
     */
    private constructor();
    /**
     * Create {@link Context} object.
     * @param interpreter Optional interpreter instance associated with the context.
     * @param globalScope Optional global scope reference.
     * @param callStack Optional function call stack reference.
     * @returns New interpreter context.
     */
    static readonly create: (interpreter?: ContextInterpreter, globalScope?: Scope, callStack?: CallFrame[]) => Context;
    /**
     * Native constants inserted into the global name table during interpreter loading.
     */
    nativeNameTable: Record<string, ComplexType>;
    /**
     * Names provided by {@link nativeNameTable}.
     */
    nativeNameSet: Set<string>;
    /**
     * Alias name table.
     */
    private aliasNameTable;
    /**
     * Alias name function. This property is set at Interpreter instantiation.
     * @param name Alias name.
     * @returns Canonical name.
     */
    aliasNameFunction: (name: string) => string;
    /**
     * Configure aliases that map alternative spellings to canonical function names.
     * @param aliasNameTable Alias patterns keyed by canonical names.
     */
    setAliasNameTable(aliasNameTable?: AliasNameTable): void;
    /**
     * Get a list of names of defined functions in builtInFunctionTable.
     */
    get builtInFunctionList(): string[];
    /**
     * Current frame (top of call stack) getter.
     */
    get currentFrame(): CallFrame | undefined;
    /**
     * Current scope (top of call stack) getter.
     */
    get currentScope(): Scope;
    /**
     * Resolve a variable name from the current scope chain.
     * @param name Identifier to resolve.
     * @returns Matching name entry, or `undefined` when not found.
     */
    resolveName(name: string): NameEntry | undefined;
    /**
     * Resolve a name using the current MATLAB/Octave-like precedence model.
     *
     * The default order is variable, registered class, local/provider function,
     * host-loadable class, explicit/wildcard imports for class/function
     * candidates, and finally built-ins. Returning a structured result keeps
     * this order visible to dispatch, `exist`, `which`, and future
     * filesystem-like lookup work.
     *
     * @param name Name requested by source code.
     * @param scope Lookup scope.
     * @param options Optional switches for focused lookup callers.
     * @returns Structured resolution result, if any.
     */
    resolveSymbol(name: string, scope?: Scope, options?: SymbolResolutionOptions): SymbolResolution | undefined;
    /**
     * Resolve a function by name from lexical scope, provider API, or built-ins.
     *
     * @param name Function name or alias.
     * @param scope Lookup scope, defaulting to the current scope.
     * @returns User-defined or built-in function node, if found.
     */
    resolveFunction(name: string, scope?: Scope): NodeFunctionDefinition | NodeBuiltInFunction | undefined;
    /**
     * Resolve a class definition by name.
     *
     * In-memory class definitions are stored as names. Provider-loaded classes
     * are registered into the global scope so later lookups reuse the same
     * metadata object.
     *
     * @param name Class name.
     * @param scope Lookup scope, defaulting to the current scope.
     * @returns Class definition, if found.
     */
    resolveClassDefinition(name: string, scope?: Scope): ClassDefinition | undefined;
    private resolveClassDefinitionByExactName;
    /**
     * Register one package/class import in a scope.
     *
     * @param qualifiedName Fully qualified import name.
     * @param scope Scope receiving the import.
     */
    defineImport(qualifiedName: string, scope?: Scope): void;
    /**
     * Define or replace a variable in the current scope.
     *
     * @param name Variable name.
     * @param value Value to store.
     */
    assignName(name: string, value: NodeInput): void;
    /**
     * Validate a resolved variable value before exposing it as an identifier expression.
     */
    private resolvedIdentifierExpression;
    /**
     * Keep an unresolved identifier as a call target placeholder.
     */
    private unresolvedCallTargetExpression;
    /**
     * Define or replace a user function in the current scope.
     *
     * @param name Function name.
     * @param func Function definition node.
     */
    assignFunction(name: string, func: NodeFunctionDefinition): void;
    /**
     * Register a class definition as a named runtime value.
     *
     * @param definition Class metadata to register.
     * @param scope Scope that should receive the class name.
     * @returns The same class definition for fluent callers.
     */
    defineClassDefinition(definition: ClassDefinition, scope?: Scope): ClassDefinition;
    /**
     * Create a child lexical scope.
     *
     * @param parent Parent scope, defaulting to the current scope.
     * @returns New child scope.
     */
    createChildScope(parent?: Scope): Scope;
    /**
     * Track assignment targets while their right-hand side is evaluated.
     * @param targets Assignment target identifiers.
     */
    pushForwardReferenceTargets(targets: string[]): void;
    /**
     * Stop tracking the current right-hand-side assignment targets.
     * @returns Removed target list, if any.
     */
    popForwardReferenceTargets(): string[] | undefined;
    /**
     * Track how many outputs the current expression context asks from a call.
     * @param count Requested output count.
     */
    pushRequestedOutputCount(count: number): void;
    /**
     * Stop tracking the current requested output count.
     * @returns Removed requested output count, if any.
     */
    popRequestedOutputCount(): number | undefined;
    /**
     * Track which requested outputs are actually assigned by the caller.
     *
     * A `false` entry corresponds to a `~` placeholder in a multiple-output
     * assignment and is exposed inside user functions through `isargout`.
     *
     * @param mask Per-output assignment flags.
     */
    pushRequestedOutputMask(mask: boolean[]): void;
    /**
     * Stop tracking the current requested-output mask.
     *
     * @returns Removed output mask, if any.
     */
    popRequestedOutputMask(): boolean[] | undefined;
    /**
     * Output count requested by the nearest evaluation context.
     */
    get requestedOutputCount(): number;
    /**
     * Return per-output assignment flags for the current expression context.
     *
     * Contexts without an explicit mask behave as though all requested outputs
     * were assigned.
     *
     * @param count Output count to materialize.
     * @returns Boolean request mask.
     */
    requestedOutputMask(count?: number): boolean[];
    /**
     * Enter a context where comma-separated lists should expand.
     *
     * @param enabled Whether expansion is enabled for the nested evaluation.
     */
    pushCommaListExpansion(enabled?: boolean): void;
    /**
     * Leave the current comma-separated-list expansion context.
     *
     * @returns Removed expansion flag, if any.
     */
    popCommaListExpansion(): boolean | undefined;
    /**
     * Whether the current evaluation context expands comma-separated lists.
     */
    get commaListExpansionEnabled(): boolean;
    /**
     * Test class member access against the active class access stack.
     *
     * @param classDefinition Class that owns the member.
     * @param access Effective access string (`public`, `protected`, `private`, or friend list).
     * @returns `true` when the current class execution context may access the member.
     */
    canAccessClassMember(classDefinition: ClassDefinition, access?: string): boolean;
    /**
     * Return the innermost class currently granting method-access privileges.
     *
     * This is used by public introspection built-ins such as
     * `mfilename("class")`; it intentionally exposes only the class name, not
     * the mutable access stack itself.
     *
     * @returns Current executing class name, or an empty string outside class methods.
     */
    currentClassAccessName(): string;
    private withClassAccess;
    private get currentForwardReferenceTargets();
    /**
     * Follow unresolved-reference metadata to build a dependency chain.
     *
     * Pending expressions can be partially re-linked while forward references
     * are resolved, so this also inspects the stored expression tree to retain
     * useful chains such as `A -> B -> C -> A`.
     */
    private getUndefinedReferenceChain;
    private getNextUndefinedReference;
    /**
     * Find the next pending identifier inside a stored expression tree.
     */
    private findPendingIdentifier;
    /**
     * Throw when resolving `name` would close an unresolved-reference cycle.
     */
    private throwIfCircularReference;
    /**
     * Resolve a value expression to a callable wrapper when possible.
     *
     * @param expr Evaluated expression that may be a function handle.
     * @returns Callable wrapper for function handles, or `undefined`.
     */
    resolveCallable(expr: NodeExpr): Callable | undefined;
    /**
     * Resolve an identifier according to MATLAB/Octave name precedence.
     *
     * Variables are preferred, followed by call-frame metadata such as
     * `nargin`, class definitions, functions, and finally undefined-reference
     * handling. When the identifier is part of a call expression, unresolved
     * names may remain as call targets for later dispatch.
     *
     * @param tree Identifier node.
     * @param scope Scope used for lookup.
     * @returns Resolved runtime value or callable placeholder.
     */
    resolveIdentifier(tree: NodeInput, scope: Scope): NodeExpr;
    /**
     * Expand a comma-separated return list into individual values.
     *
     * Non-list values are reduced to their first return value and wrapped in a
     * single-element array. This mirrors MATLAB/Octave behavior for cell and
     * struct comma-separated lists in calls and assignments.
     *
     * @param value Evaluated value or return list.
     * @returns Expanded values.
     */
    expandCommaSeparatedList(value: NodeInput): NodeInput[];
    /**
     * Reduce a non-comma-list value before treating it as one scalar expansion
     * item.
     */
    private reducedCommaListScalar;
    /**
     * Evaluate one call/assignment expression with comma-list expansion enabled.
     *
     * @param arg Expression to evaluate.
     * @returns Expanded values produced by the expression.
     */
    evaluateCommaListExpression(arg: NodeExpr): NodeInput[];
    /**
     * Evaluate and expand a list of positional call arguments.
     *
     * @param args Argument expressions.
     * @returns Expanded argument values retyped for call helpers.
     */
    expandCommaListArguments(args: CallArgumentValue[]): CallArgumentValue[];
    /**
     * Evaluate one call argument with comma-list expansion and expression
     * validation.
     */
    private evaluateExpandedArgument;
    private evaluateArgs;
    /**
     * Evaluate built-in arguments while preserving MATLAB SetGet `Name=Value`
     * syntax for the public `set` function.
     *
     * General built-ins receive evaluated positional values. `set` is special:
     * MATLAB treats top-level `Name=Value` arguments as property/value pairs,
     * not as ordinary assignment expressions. Keeping the conversion here keeps
     * the behavior local to the built-in dispatch path.
     *
     * @param node Built-in function node.
     * @param args Raw call argument expressions.
     * @param parent Call-site node used for diagnostics.
     * @returns Evaluated argument values.
     */
    evaluateBuiltInArgs(node: NodeBuiltInFunction, args: CallArgumentValue[], parent: NodeInput): ExpressionBoundaryValue[];
    /**
     * Throw an evaluation error annotated with the current stack trace.
     *
     * @param message Error message.
     */
    throwEvalError(message: string): never;
    /**
     * Throw a reference error annotated with the current stack trace.
     *
     * @param message Error message.
     */
    throwReferenceError(message: string): never;
    /**
     * Throw an undefined-reference error annotated with the current stack trace.
     *
     * @param identifier Missing identifier.
     */
    throwUndefinedReferenceError(identifier: string): never;
    /**
     * Throw a circular-reference error annotated with the current stack trace.
     *
     * @param chain Dependency chain that closes the cycle.
     */
    throwCircularReferenceError(chain: string[]): never;
    /**
     * Throw a syntax error annotated with the current stack trace.
     *
     * @param message Error message.
     */
    throwSyntaxError(message: string): never;
    private getCurrentFunctionDefinition;
    /**
     * Return whether execution is currently inside a user-defined function.
     *
     * Built-in helper frames and temporary eval frames may sit on top of the
     * stack, so this intentionally searches the stack instead of inspecting
     * only the current top frame.
     */
    isInsideUserFunction(): boolean;
    /**
     * Return the virtual source name of the current user-defined callable.
     */
    currentFunctionSourceName(): string;
    private getCurrentFunctionCountFrame;
    private getCallerWorkspace;
    /**
     * Resolve a MATLAB-like workspace selector.
     *
     * @param name Workspace name such as `base` or `caller`.
     * @param forAssignment Whether the resolved workspace will be assigned into.
     * @returns Target scope.
     */
    resolveWorkspace(name: string, forAssignment?: boolean): Scope;
    /**
     * Return the current function's input argument count.
     *
     * @param name Built-in name used for diagnostics.
     * @returns Numeric scalar count.
     */
    currentFunctionArgumentCount(name: 'nargin' | 'nargout'): ComplexType;
    /**
     * Return the current function's input count, or zero outside a function.
     */
    currentFunctionArgumentCountOrZero(): ComplexType;
    /**
     * Return the output count requested from the current function.
     *
     * @param name Built-in name used for diagnostics.
     * @returns Numeric scalar count.
     */
    currentFunctionOutputCount(name: 'nargin' | 'nargout'): ComplexType;
    /**
     * Return the current requested output count, or zero outside a function.
     */
    currentFunctionOutputCountOrZero(): ComplexType;
    /**
     * Return whether one or more current function outputs are requested.
     *
     * `isargout` is true only for output positions within `nargout` whose
     * caller-side target was not `~`.
     *
     * @param indexNode One-based output index or numeric array of indexes.
     * @returns Logical scalar or array matching the input shape.
     */
    currentFunctionOutputIsRequested(indexNode: NodeInput): NodeInput;
    /**
     * Implement `inputname` for the current function frame.
     *
     * @param indexNode One-based argument index.
     * @returns Original caller expression text when available.
     */
    currentFunctionInputName(indexNode: NodeInput, onlyVariableNames?: boolean, unparse?: (arg: ExpressionBoundaryValue) => string): CharString;
    /**
     * Return the current function display name.
     */
    currentFunctionName(): string;
    /**
     * Declare a persistent variable in the current function.
     *
     * @param name Variable name.
     * @param value Initial value, when supplied by the declaration.
     * @param scope Function scope receiving the live binding.
     */
    declarePersistent(name: string, value: RuntimeExpressionValue | undefined, scope: Scope): void;
    /**
     * Load persistent variables into a function call scope.
     *
     * @param func Function definition whose persistent storage should be loaded.
     * @param scope Function call scope.
     */
    loadPersistentVariables(func: NodeFunctionDefinition, scope: Scope): void;
    /**
     * Store persistent variables after a function call completes.
     *
     * @param func Function definition whose persistent storage should be updated.
     * @param scope Function call scope.
     */
    storePersistentVariables(func: NodeFunctionDefinition, scope: Scope): void;
    /**
     * Declare a variable as global in a scope.
     *
     * @param name Global variable name.
     * @param value Optional initial value.
     * @param scope Scope that should reference the global binding.
     */
    declareGlobal(name: string, value: RuntimeExpressionValue | undefined, scope: Scope): void;
    /**
     * Clear global bindings from the global scope and active frames.
     *
     * @param names Optional subset of global names to clear.
     */
    clearGlobalVariables(names?: string[]): void;
    /**
     * Clear loaded class definitions from the global scope and active frames.
     *
     * Host/source resolvers are intentionally left untouched so qualified or
     * imported class names can be loaded again after `clear classes`.
     */
    clearClassDefinitions(): void;
    /**
     * Clear ordinary variables from the current workspace.
     *
     * Native constants and class definitions are intentionally preserved. The
     * latter are runtime type metadata rather than user workspace variables.
     */
    clearCurrentVariables(names?: string[]): void;
    private resolveCallSite;
    private static debugIdentifier;
    /**
     * Return normalized input signatures for a built-in node.
     *
     * @param node Built-in function node.
     * @returns Input signature overloads.
     */
    builtInInputSignatures(node: NodeBuiltInFunction): BuiltInFunctionInputSignature[];
    /**
     * Return normalized output signatures for a built-in node.
     *
     * @param node Built-in function node.
     * @returns Output signature overloads.
     */
    builtInOutputSignatures(node: NodeBuiltInFunction): BuiltInFunctionInputSignature[];
    /**
     * Compute the MATLAB-like declared arity for built-in signatures.
     *
     * @param signatures Input or output signature overloads.
     * @returns Fixed or negative variadic arity, when declared.
     */
    builtInDeclaredArity(signatures: BuiltInFunctionInputSignature[]): number | undefined;
    validateBuiltInInputArity(node: NodeBuiltInFunction, argCount: number): void;
    validateBuiltInInputParameters(node: NodeBuiltInFunction, args: NodeInput[]): void;
    private valueDimensions;
    private sizeReturnList;
    /**
     * Give scalar class objects the normal MATLAB overload opportunity for
     * selected built-ins before the native implementation runs.
     *
     * @param node Built-in function node being invoked.
     * @param evaluatedArgs Already evaluated call arguments.
     * @param parent Call-site node used for diagnostics.
     * @returns Class method result when an accessible overload exists.
     */
    private callClassBuiltinMethod;
    private callFunctionDefinition;
    private instantiateClassDefaults;
    private constructClassInstance;
    constructSuperclassInstance(instance: ClassInstance, superclassDefinition: ClassDefinition, args: CallArgumentValue[], parent: NodeInput): ClassInstance;
    private constructClassInstanceWithInstance;
    /**
     * Call an instance method with class access and value/handle receiver rules.
     *
     * @param instance Receiver object.
     * @param method Method metadata selected from the class hierarchy.
     * @param args Explicit method arguments, excluding the receiver.
     * @param parent Call-site node used for stack traces.
     * @returns Method return expression or return list.
     */
    callClassInstanceMethod(instance: ClassInstance, method: ClassMethodDefinition, args: CallArgumentValue[], parent: NodeInput): NodeExpr;
    /**
     * Validate the implicit object argument passed to instance method bodies.
     */
    private classMethodReceiverArgument;
    /**
     * Call a static class method with class access enabled.
     *
     * @param method Static method metadata.
     * @param args Method argument expressions.
     * @param parent Call-site node used for stack traces.
     * @returns Method return expression or return list.
     */
    callClassStaticMethod(method: ClassMethodDefinition, args: CallArgumentValue[], parent: NodeInput): NodeExpr;
    /**
     * Materialize a concrete class method body from an external method file.
     *
     * @param method Method metadata whose AST node may still be a classdef prototype.
     */
    private ensureConcreteClassMethod;
    private validateLoadedClassMethodSignature;
    private callClassEmptyMethod;
    /**
     * Validate expanded positional argument values.
     */
    private expressionValues;
    /**
     * Validate one value before exposing it as an ordinary argument expression.
     */
    private expressionValue;
    /**
     * Validate one evaluated value before storing it in runtime-owned state.
     */
    private runtimeExpressionValue;
    /**
     * Evaluate one AST node through the interpreter and reduce lazy return-list
     * carriers without applying expression-only validation.
     */
    private evaluatedExecutionResult;
    /**
     * Evaluate one AST node without reducing comma-separated return-list
     * carriers, for contexts that must expand them explicitly.
     */
    private rawEvaluationResult;
    /**
     * Evaluate one AST expression and validate the reduced value before it
     * crosses a context-owned argument/default/receiver boundary.
     */
    private evaluatedExpressionValue;
    /**
     * Validate values that are exposed through lazy return-list helpers.
     */
    private returnExpression;
    /**
     * Validate several values before exposing them through lazy return lists.
     */
    private returnExpressions;
    /**
     * Reduce a class-dispatch result array to its scalar/array return value and
     * validate scalar 1x1 contents before exposing them as expression results.
     */
    private scalarArrayReturnExpression;
    /**
     * Invoke one class method expecting a single output and reduce lazy
     * return-list carriers before storing the result in array dispatch paths.
     */
    private reducedClassMethodResult;
    /**
     * Read one class-instance element from an object array.
     */
    private classInstanceArrayElement;
    /**
     * Invoke each bound method stored in an object array.
     *
     * MATLAB/Octave dot access can produce arrays of method handles. Calling
     * that array evaluates each bound method with one requested output and then
     * normalizes the scalar array result through the shared return-expression
     * boundary before exposing it to the caller.
     *
     * @param expr Array containing bound method runtime values.
     * @param args Call arguments.
     * @param parent AST node that owns the call.
     * @returns Scalar or array expression result.
     */
    private callClassBoundMethodArray;
    private callFunctionalClassMethodArray;
    /**
     * Delete a handle class instance, honoring an overloadable `delete` method.
     *
     * @param instance Handle instance to delete.
     * @param parent Call-site node used for stack traces.
     * @returns Void node.
     */
    deleteClassInstance(instance: ClassInstance, parent: NodeInput): NodeExpr;
    private evaluateFunctionalClassMethodReceiver;
    private isFunctionalClassMethodReceiver;
    private callFunctionalClassMethod;
    /**
     * Dispatch a built-in, anonymous function, or user-defined function call.
     *
     * @param callable Resolved callable wrapper.
     * @param args Raw call argument expressions.
     * @param parent Call-site node used for metadata and stack traces.
     * @returns Call result.
     */
    callCallable(callable: Callable, args: CallArgumentValue[], parent: NodeInput): NodeExpr;
    private valueReturnList;
    private callFunctionalOperatorOverload;
    /**
     * Dispatch built-in operator functions reached without an index-expression
     * wrapper, such as `feval('plus', obj, obj)`.
     */
    private callCallableFunctionalOperatorOverload;
    /**
     * Classify an evaluated expression before applying call/index syntax.
     *
     * This helper keeps MATLAB/Octave dispatch precedence visible in one
     * place: callable handles/functions first, class method wrappers next,
     * constructors and functional method syntax after that, and native indexing
     * as the final fallback.
     *
     * @param expr Evaluated callee or indexed expression.
     * @param parent Index expression node carrying delimiter metadata.
     * @param args Raw call/index arguments, used only to classify functional method calls.
     * @returns Structured dispatch decision.
     */
    resolveCallDispatch(expr: NodeExpr, parent: NodeInput, args?: CallArgumentValue[]): CallDispatch;
    /**
     * Execute one non-indexing call dispatch decision.
     *
     * @param dispatch Structured dispatch decision.
     * @param args Raw call argument expressions.
     * @param parent Index expression node carrying delimiter metadata.
     * @returns Call result, or `undefined` when native indexing should handle it.
     */
    private applyCallDispatch;
    /**
     * Apply native MATLAB/Octave indexing after call dispatch declines.
     *
     * @param expr Evaluated indexed expression.
     * @param args Raw index expressions.
     * @param parent Index expression node carrying delimiter metadata.
     * @returns Indexed value or comma-separated return list.
     */
    private applyNativeIndexing;
    /**
     * Apply call or indexing syntax to an evaluated expression.
     *
     * MATLAB/Octave use the same parentheses for function calls and array
     * indexing. This dispatcher first attempts callable/class dispatch and then
     * falls back to array/cell indexing, including comma-separated-list rules.
     *
     * @param expr Evaluated callee/indexed expression.
     * @param args Raw index or call argument expressions.
     * @param parent Index expression node carrying delimiter metadata.
     * @returns Call or indexing result.
     */
    apply(expr: NodeExpr, args: CallArgumentValue[], parent: NodeInput): NodeExpr;
    /**
     * Define function in builtInFunctionTable.
     * @param id Name of function.
     * @param func Function body.
     * @param map `true` if function is a mapper function.
     * @param ev A `boolean` array indicating which function argument should
     * be evaluated before executing the function. If array is zero-length all
     * arguments are evaluated.
     */
    defineBuiltInFunction(id: string, func: Function, mapper?: boolean, ev?: boolean[], signature?: BuiltInFunctionSignature): void;
    /**
     * Merge external built-in functions into the current built-in table.
     * @param table Built-in functions to add or override.
     */
    assignBuiltInFunctionTable(table?: Record<string, NodeBuiltInFunction>): void;
    /**
     * Define unary operator function in builtInFunctionTable.
     * @param id Name of function.
     * @param func Function body.
     */
    defineUnaryOperatorFunction(id: KeyOfTypeOfMathOperation, func: UnaryMathOperation): void;
    /**
     * Define binary operator function in builtInFunctionTable.
     * @param id Name of function.
     * @param func Function body.
     */
    defineBinaryOperatorFunction(id: KeyOfTypeOfMathOperation, func: BinaryMathOperation): void;
    /**
     * Define a left-associative operator function that accepts two or more operands.
     * @param id Operator name.
     * @param func Binary operation used to fold the operands.
     */
    defineLeftAssociativeMultipleOperationFunction(id: KeyOfTypeOfMathOperation, func: BinaryMathOperation): void;
    /**
     * Push a new frame onto the call stack.
     *
     * @param frame - CallFrame to push
     */
    pushCallStackFrame(frame: CallFrame): void;
    /**
     * Pop the current frame from the call stack.
     *
     * @returns Removed frame
     */
    popCallStackFrame(): CallFrame | undefined;
    /**
     * Returns a snapshot of the current stack trace.
     *
     * Top frame is the first element.
     */
    private getStackTrace;
}
export type { CallDispatch, CallDispatchKind, SymbolResolution, SymbolResolutionKind, SymbolResolutionOptions, SymbolResolutionSource };
export { Context, ReturnSignal, BreakSignal, ContinueSignal };
export default Context;