import { Parser, type ErrorObject } from '../index.mts';
import type { TokenData } from './Lexer.mts';
import type { ParseNode } from './ParseNode.mts';
export declare enum Flag {
    return = 1,
    await = 2,
    yield = 4,
    parameters = 8,
    newTarget = 16,
    importMeta = 32,
    superCall = 64,
    superProperty = 128,
    in = 256,
    default = 512,
    module = 1024,
    classStaticBlock = 2048
}
export interface DeclarationInfo {
    readonly name: string;
    readonly node: ParseNode;
}
export declare function getDeclarations(node: ParseNode | readonly ParseNode[]): DeclarationInfo[];
export type ScopeFlagSetters = {
    readonly [P in (keyof typeof Flag) & string]?: boolean;
} & {
    readonly lexical?: boolean;
    readonly variable?: boolean;
    readonly variableFunctions?: boolean;
    readonly private?: boolean;
    readonly label?: LabelType | 'boundary';
    readonly strict?: boolean;
};
export interface ScopeInfo {
    readonly flags: ScopeFlagSetters;
    readonly lexicals: Set<string>;
    readonly variables: Set<string>;
    readonly functions: Set<string>;
    readonly parameters: Set<string>;
}
export interface PrivateScopeInfo {
    readonly outer: PrivateScopeInfo | undefined;
    readonly names: Map<string, Set<'field' | 'method' | 'get' | 'set'>>;
}
export interface UndefinedPrivateAccessInfo {
    readonly node: ParseNode;
    readonly name: string;
    readonly scope: PrivateScopeInfo | undefined;
}
export interface ArrowInfo {
    readonly isAsync: boolean;
    hasTrailingComma: boolean;
    readonly yieldExpressions: ParseNode[];
    readonly awaitExpressions: ParseNode[];
    readonly awaitIdentifiers: ParseNode[];
    merge(other: ArrowInfo): void;
}
export interface AssignmentInfo {
    readonly type: 'assign' | 'arrow' | 'for';
    readonly earlyErrors: ErrorObject[];
    clear(): void;
}
export type LabelType = 'switch' | 'loop';
export interface Label {
    type: LabelType | null;
    readonly name?: string;
    readonly nextToken?: TokenData | null;
}
export declare class Scope {
    private readonly parser;
    private readonly scopeStack;
    labels: Label[];
    readonly arrowInfoStack: (ArrowInfo | null)[];
    readonly assignmentInfoStack: AssignmentInfo[];
    private arrowParameterCandidateDepth;
    private arrowBodyDepth;
    readonly exports: Set<string>;
    readonly undefinedExports: Map<string, ParseNode.ModuleExportName>;
    privateScope: PrivateScopeInfo | undefined;
    private readonly undefinedPrivateAccesses;
    private flags;
    constructor(parser: Parser);
    hasReturn(): boolean;
    hasAwait(): boolean;
    hasYield(): boolean;
    hasNewTarget(): boolean;
    hasSuperCall(): boolean;
    hasSuperProperty(): boolean;
    hasImportMeta(): boolean;
    hasIn(): boolean;
    inParameters(): boolean;
    inClassStaticBlock(): boolean;
    isDefault(): boolean;
    isModule(): boolean;
    inArrowParameterCandidate(): boolean;
    enterArrowParameterCandidate(): void;
    exitArrowParameterCandidate(): void;
    inArrowBody(): boolean;
    enterArrowBody(): void;
    exitArrowBody(): void;
    with<R>(flags: ScopeFlagSetters, f: () => R): R;
    pushArrowInfo(isAsync?: boolean): void;
    popArrowInfo(): ArrowInfo;
    get arrowInfo(): ArrowInfo | null | undefined;
    pushAssignmentInfo(type: 'assign' | 'arrow' | 'for'): void;
    popAssignmentInfo(): AssignmentInfo;
    registerObjectLiteralEarlyError(error: ErrorObject): void;
    lexicalScope(): ScopeInfo;
    variableScope(): ScopeInfo;
    declare(node: ParseNode | readonly ParseNode[], type: 'private', extraType?: 'field' | 'method' | 'get' | 'set'): void;
    declare(node: ParseNode | readonly ParseNode[], type: 'lexical' | 'lexical-allow-let' | 'import' | 'function' | 'parameter' | 'variable' | 'export'): void;
    checkUndefinedExports(NamedExports: ParseNode.NamedExports): void;
    checkUndefinedPrivate(PrivateIdentifier: ParseNode.PrivateIdentifier): void;
}
//# sourceMappingURL=Scope.d.mts.map