tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/parser.d.ts

@@ -0,0 +1,604 @@
+import { Block, CaseBlock, CatchClause, ExternalModuleIndicatorOptions, Identifier, ImportAttributes, ImportClause, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxOpeningElement, ModifierList, Node, NodeFlags, NodeList, ObjectLiteralExpression, ParseOptions, ScriptKind, SourceFile, TemplateHead, TemplateLiteralTypeSpan, TemplateSpan, ThisTypeNode, Token, Tristate, TypeParameterDeclaration, VariableDeclaration, VariableDeclarationList, type EntityName, type Expression, type Statement, type TypeNode } from './ast.js';
+import { OperatorPrecedence } from './ast-utilities.js';
+import { Diagnostic, type DiagnosticMessage } from './diagnostics.js';
+import { JSDocParser } from './jsdoc.js';
+import { ModuleKind } from './module-resolution-types.js';
+import { Scanner, ScannerErrorReporter, ScannerState } from './scanner.js';
+import { SyntaxKind } from './syntax-kind.js';
+import { LanguageVariant } from './types.js';
+declare const enum ParsingContext {
+    SourceElements = 0,
+    BlockStatements = 1,
+    SwitchClauses = 2,
+    SwitchClauseStatements = 3,
+    TypeMembers = 4,
+    ClassMembers = 5,
+    EnumMembers = 6,
+    HeritageClauseElement = 7,
+    VariableDeclarations = 8,
+    ObjectBindingElements = 9,
+    ArrayBindingElements = 10,
+    ArgumentExpressions = 11,
+    ObjectLiteralMembers = 12,
+    JsxAttributes = 13,
+    JsxChildren = 14,
+    ArrayLiteralMembers = 15,
+    Parameters = 16,
+    JSDocParameters = 17,
+    RestProperties = 18,
+    TypeParameters = 19,
+    TypeArguments = 20,
+    TupleElementTypes = 21,
+    HeritageClauses = 22,
+    ImportOrExportSpecifiers = 23,
+    ImportAttributes = 24,
+    JSDocComment = 25,
+    Count = 26
+}
+/** Which parser `parseList` and `parseDelimitedList` call for each element. */
+declare const enum ListElement {
+    Statement = 0,
+    TopLevelStatement = 1,
+    CaseOrDefaultClause = 2,
+    VariableDeclaration = 3,
+    VariableDeclarationAllowExclamation = 4,
+    ArrayBindingElement = 5,
+    ObjectBindingElement = 6,
+    ClassElement = 7,
+    HeritageClause = 8,
+    ExpressionWithTypeArguments = 9,
+    EnumMember = 10,
+    ImportSpecifier = 11,
+    ExportSpecifier = 12,
+    Type = 13,
+    ImportAttribute = 14,
+    TypeMember = 15,
+    TypeParameter = 16,
+    Parameter = 17,
+    /** A parameter of a signature, using `signatureParameter*` state. */
+    SignatureParameter = 18,
+    TupleElement = 19,
+    JsxAttribute = 20,
+    ArgumentExpression = 21,
+    ArrayLiteralElement = 22,
+    ObjectLiteralElement = 23
+}
+export declare const enum ParseFlags {
+    None = 0,
+    Yield = 1,
+    Await = 2,
+    Type = 4,
+    IgnoreMissingOpenBrace = 16,
+    JSDoc = 32
+}
+/** How an identifier is used, which decides whether it holds a flow node. */
+export declare const enum IdentifierUse {
+    /** An expression or another reference: a `ReferenceIdentifier`. */
+    Reference = 0,
+    /** A declaration, property, property access or type name, whose flow node nothing reads: an `Identifier`. */
+    Name = 1,
+    /** An object literal element's name: a name before `:`, `(` or `<`, a reference in a shorthand property. */
+    ElementName = 2
+}
+/** What the scanner saw of the JSDoc comments preceding a token. */
+export declare const enum JSDocScannerInfo {
+    None = 0,
+    HasJSDoc = 1,
+    HasDeprecated = 2,
+    HasSeeOrLink = 4
+}
+/** Parser state saved by `mark` for speculative parsing. */
+export declare class ParserState extends ScannerState {
+    contextFlags: NodeFlags;
+    diagnosticsLength: number;
+    jsDiagnosticsLength: number;
+    jsDocInfosLength: number;
+    reparsedClonesLength: number;
+    statementHasAwaitIdentifier: boolean;
+    hasParseError: boolean;
+    constructor(scanner: Scanner, contextFlags: NodeFlags, diagnosticsLength: number, jsDiagnosticsLength: number, jsDocInfosLength: number, reparsedClonesLength: number, statementHasAwaitIdentifier: boolean, hasParseError: boolean);
+    /** Overwrites this state with the parser's current one, like `Parser.mark`. */
+    assignParser(p: Parser): void;
+}
+/** Parses `text` as the file `fileName`. The script kind defaults to the one implied by the extension. */
+export declare function parseSourceFile(fileName: string, text: string, options?: ParseOptions): SourceFile;
+/** Parses `text` as an entity name like `a.b.c`, or returns undefined if it isn't one. */
+export declare function parseIsolatedEntityName(text: string): EntityName | undefined;
+export declare function getScriptKindFromFileName(fileName: string): ScriptKind;
+export declare class Parser extends ScannerErrorReporter {
+    readonly scanner: Scanner;
+    readonly fileName: string;
+    readonly path: string;
+    readonly sourceText: string;
+    readonly scriptKind: ScriptKind;
+    readonly languageVariant: LanguageVariant;
+    readonly externalModuleIndicatorOptions: ExternalModuleIndicatorOptions;
+    diagnostics: Diagnostic[];
+    jsDiagnostics: Diagnostic[];
+    jsDocDiagnostics: Diagnostic[];
+    currentToken: SyntaxKind;
+    sourceFlags: NodeFlags;
+    contextFlags: NodeFlags;
+    parsingContexts: number;
+    statementHasAwaitIdentifier: boolean;
+    hasDeprecatedTag: boolean;
+    hasParseError: boolean;
+    /** Identifier and interned literal texts in parse order, each identifier text once (other texts may repeat). */
+    identifierTexts: string[];
+    identifierCount: number;
+    nodeCount: number;
+    /** Start positions of parenthesized arrow function candidates that turned out not to be arrows. */
+    notParenthesizedArrow: Set<number>;
+    /** Pairs of [start, end) statement indexes that may need reparsing for top-level await. */
+    possibleAwaitSpans: number[];
+    /** Nodes produced by JSDoc reparsing to insert before the current list element. */
+    reparseList: Node[];
+    private readonly reparseLists;
+    private reparseDepth;
+    reparsedClones: Node[];
+    /** Nodes with eagerly parsed JSDoc, for rewinding. */
+    jsDocInfos: Node[];
+    /** The eagerly parsed JSDoc of this file's nodes by node id; becomes `SourceFile.jsDocs`. */
+    jsDocTable: Map<number, Node[]> | undefined;
+    signatureParameterInAwaitContext: boolean;
+    signatureParameterAllowAmbiguity: boolean;
+    signatureParameterFlags: ParseFlags;
+    /** Parses JSDoc comments and, in JavaScript files, reparses their tags. */
+    jsdoc: JSDocParser;
+    /**
+     * Returned instead of `undefined` by hot element parsers: a `Node | undefined` result is boxed natively
+     * for every node returned.
+     */
+    readonly noElement: Node;
+    private readonly speculation;
+    private speculationDepth;
+    constructor(fileName: string, path: string, sourceText: string, scriptKind: ScriptKind, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions, 
+    /** The scanner copies the code units of only the ranges it is asked to (`Scanner.loadUnits`). */
+    unitsOnDemand?: boolean);
+    /**
+     * Frees the scanner's copy of the text once the parser is done, and drops the references back to
+     * this parser from its scanner and JSDoc parser. Natively, the parser is then freed as soon as its
+     * caller lets go of it, instead of at a cycle collection, which may come much later (on a parse
+     * thread, not before the thread exits).
+     */
+    release(): void;
+    token(): SyntaxKind;
+    isJavaScript(): boolean;
+    onError(message: DiagnosticMessage, start: number, length: number, args: readonly string[]): void;
+    /** Reports an error unless the previous one starts at the same position. */
+    parseErrorAt(pos: number, end: number, message: DiagnosticMessage, args?: readonly string[]): Diagnostic | undefined;
+    parseErrorAtCurrentToken(message: DiagnosticMessage, args?: readonly string[]): Diagnostic | undefined;
+    /** A diagnostic for TypeScript-only syntax in a JavaScript file, starting after trivia. */
+    jsErrorAt(pos: number, end: number, message: DiagnosticMessage, args?: readonly string[]): void;
+    mark(): ParserState;
+    /** Attaches eagerly parsed JSDoc to `node`, undone by `rewind`. */
+    setJSDoc(node: Node, jsDoc: Node[]): void;
+    rewind(state: ParserState): void;
+    /** Like `mark`, but reuses a state object; balance every call with `endSpeculation`. */
+    beginSpeculation(): ParserState;
+    /** Releases the state from `beginSpeculation`, keeping the current parser state. */
+    endSpeculation(_state: ParserState): void;
+    /** Runs `callback` and restores the parser state afterwards. */
+    lookAhead(callback: (p: Parser) => boolean): boolean;
+    nextToken(): SyntaxKind;
+    nextTokenWithoutCheck(): SyntaxKind;
+    nextTokenJSDoc(): SyntaxKind;
+    nextJSDocCommentTextToken(inBackticks: boolean): SyntaxKind;
+    nodePos(): number;
+    hasPrecedingLineBreak(): boolean;
+    jsdocScannerInfo(): JSDocScannerInfo;
+    setContextFlags(flags: NodeFlags, value: boolean): void;
+    inYieldContext(): boolean;
+    inDisallowInContext(): boolean;
+    inDisallowConditionalTypesContext(): boolean;
+    inDecoratorContext(): boolean;
+    inAwaitContext(): boolean;
+    newNodeList(pos: number, end: number, nodes: Node[]): NodeList;
+    newModifierList(pos: number, end: number, nodes: Node[]): ModifierList;
+    finishNode(node: Node, pos: number): Node;
+    finishNodeWithEnd(node: Node, pos: number, end: number): Node;
+    overrideParentInImmediateChildren(node: Node): void;
+    parseSourceFileWorker(): SourceFile;
+    newSourceFile(statements: NodeList, eof: Token): SourceFile;
+    finishSourceFile(result: SourceFile, isDeclarationFile: boolean): void;
+    parseToplevelStatement(index: number): Statement;
+    reparseTopLevelAwait(sourceFile: SourceFile): SourceFile;
+    /** The element, or `noElement` if a signature parameter can't start here. */
+    parseListElement(element: ListElement, index: number): Node;
+    parseListIndex(kind: ParsingContext, element: ListElement): Node[];
+    parseList(kind: ParsingContext, element: ListElement): NodeList;
+    /** The list, or undefined if an element parser returned undefined. */
+    parseDelimitedList(kind: ParsingContext, element: ListElement): NodeList | undefined;
+    /** The list; a missing list if `opening` is absent; undefined if an element parser returned undefined. */
+    parseBracketedList(kind: ParsingContext, element: ListElement, opening: SyntaxKind, closing: SyntaxKind): NodeList | undefined;
+    parseEmptyNodeList(): NodeList;
+    createMissingList(): NodeList;
+    /** Reports an error for the current token; returns true if parsing the list should stop. */
+    abortParsingListOrMoveToNextToken(kind: ParsingContext): boolean;
+    /** Whether the current token is an element or terminator of the current list or an enclosing one. */
+    isInSomeParsingContext(): boolean;
+    parsingContextErrors(context: ParsingContext): void;
+    isListElement(parsingContext: ParsingContext, inErrorRecovery: boolean): boolean;
+    isListTerminator(kind: ParsingContext): boolean;
+    parseExpectedJSDoc(kind: SyntaxKind): boolean;
+    parseExpectedMatchingBrackets(openKind: SyntaxKind, closeKind: SyntaxKind, openParsed: boolean, openPosition: number): void;
+    parseOptional(token: SyntaxKind): boolean;
+    parseExpected(kind: SyntaxKind): boolean;
+    parseExpectedWithoutAdvancing(kind: SyntaxKind): boolean;
+    parseExpectedWithDiagnostic(kind: SyntaxKind, message: DiagnosticMessage | undefined, shouldAdvance: boolean): boolean;
+    parseTokenNode(): Token;
+    parseExpectedToken(kind: SyntaxKind): Token;
+    parseOptionalToken(kind: SyntaxKind): Token | undefined;
+    parseExpectedTokenJSDoc(kind: SyntaxKind): Token;
+    parseOptionalTokenJSDoc(kind: SyntaxKind): Token | undefined;
+    parseStatement(): Statement;
+    parseDeclaration(): Statement;
+    parseDeclarationWorker(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    isLetDeclaration(): boolean;
+    parseBlock(ignoreMissingOpenBrace: boolean, diagnosticMessage: DiagnosticMessage | undefined): Block;
+    parseEmptyStatement(): Statement;
+    /** Finishes `node` and attaches its JSDoc. */
+    finishWithJSDoc(node: Node, pos: number, jsdoc: JSDocScannerInfo): Node;
+    parseIfStatement(): Statement;
+    parseDoStatement(): Statement;
+    parseWhileStatement(): Statement;
+    parseForOrForInOrForOfStatement(): Statement;
+    parseBreakStatement(): Statement;
+    parseContinueStatement(): Statement;
+    parseIdentifierUnlessAtSemicolon(): Identifier | undefined;
+    parseReturnStatement(): Statement;
+    parseWithStatement(): Statement;
+    parseCaseClause(): Node;
+    parseDefaultClause(): Node;
+    parseCaseOrDefaultClause(): Node;
+    parseCaseBlock(): CaseBlock;
+    parseSwitchStatement(): Statement;
+    parseThrowStatement(): Statement;
+    parseTryStatement(): Statement;
+    parseCatchClause(): CatchClause;
+    parseDebuggerStatement(): Statement;
+    parseExpressionOrLabeledStatement(): Statement;
+    parseVariableStatement(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseVariableDeclarationList(inForStatementInitializer: boolean): VariableDeclarationList;
+    parseVariableDeclaration(): VariableDeclaration;
+    parseVariableDeclarationAllowExclamation(): VariableDeclaration;
+    parseVariableDeclarationWorker(allowExclamation: boolean): VariableDeclaration;
+    parseIdentifierOrPattern(): Node;
+    parseIdentifierOrPatternWithDiagnostic(privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined): Node;
+    parseArrayBindingPattern(): Node;
+    parseArrayBindingElement(): Node;
+    parseObjectBindingPattern(): Node;
+    parseObjectBindingElement(): Node;
+    parseInitializer(): Expression | undefined;
+    /** `parseInitializer` outside yield, await and disallow-in contexts. */
+    parseInitializerInPropertyContext(): Expression | undefined;
+    parseTypeAnnotation(): TypeNode | undefined;
+    parseFunctionDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseClassDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseClassExpression(): Expression;
+    parseClassDeclarationOrExpression(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined, kind: SyntaxKind): Node;
+    parseNameOfClassDeclarationOrExpression(): Identifier | undefined;
+    isImplementsClause(): boolean;
+    parseHeritageClauses(): NodeList | undefined;
+    parseHeritageClause(): Node;
+    parseExpressionWithTypeArguments(): Node;
+    parseClassElement(): Node;
+    parseClassStaticBlockDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Node;
+    parseClassStaticBlockBody(): Block;
+    tryParseConstructorDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Node | undefined;
+    parsePropertyOrMethodDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Node;
+    parseMethodDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined, asteriskToken: Token | undefined, name: Node, questionToken: Token | undefined, diagnosticMessage: DiagnosticMessage | undefined): Node;
+    parsePropertyDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined, name: Node, questionToken: Token | undefined): Node;
+    parseSemicolonAfterPropertyName(name: Node, type: TypeNode | undefined, initializer: Expression | undefined): void;
+    parseErrorForMissingSemicolonAfter(node: Node): void;
+    parseErrorForInvalidName(nameDiagnostic: DiagnosticMessage, blankDiagnostic: DiagnosticMessage, tokenIfBlankName: SyntaxKind): void;
+    parseInterfaceDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseTypeAliasDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseEnumMember(): Node;
+    parseEnumDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseModuleDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseAmbientExternalModuleDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseModuleBlock(): Node;
+    parseModuleOrNamespaceDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined, nested: boolean, keyword: SyntaxKind): Node;
+    parseImportDeclarationOrImportEqualsDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    tokenAfterImportDefinitelyProducesImportDeclaration(): boolean;
+    /** In `import id ___`, whether the token makes this an ImportDeclaration rather than ImportEqualsDeclaration. */
+    tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration(): boolean;
+    parseImportEqualsDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined, identifier: Identifier, isTypeOnly: boolean): Node;
+    parseModuleReference(): Node;
+    parseExternalModuleReference(): Node;
+    parseModuleSpecifier(): Expression;
+    tryParseImportClause(identifier: Identifier | undefined, pos: number, phaseModifier: SyntaxKind, skipJSDocLeadingAsterisks: boolean): ImportClause | undefined;
+    parseImportClause(identifier: Identifier | undefined, pos: number, phaseModifier: SyntaxKind, skipJSDocLeadingAsterisks: boolean): ImportClause;
+    parseNamespaceImport(): Node;
+    parseNamedImports(): Node;
+    parseImportSpecifier(): Node;
+    parseExportSpecifier(): Node;
+    parseImportOrExportSpecifier(kind: SyntaxKind): Node;
+    canParseModuleExportName(): boolean;
+    /** Whether the module export name at the current token is acceptable. */
+    isModuleExportNameOk(disallowKeywords: boolean): boolean;
+    parseModuleExportName(): Node;
+    tryParseImportAttributes(): ImportAttributes | undefined;
+    parseExportAssignment(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseNamespaceExportDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseExportDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement;
+    parseNamespaceExport(pos: number): Node;
+    parseNamedExports(): Node;
+    parseType(): TypeNode;
+    /** `parseType` with conditional types disallowed or allowed. */
+    parseTypeInConditionalContext(disallowConditionalTypes: boolean): TypeNode;
+    parseUnionTypeOrHigher(): TypeNode;
+    parseIntersectionTypeOrHigher(): TypeNode;
+    /** `parseIntersectionTypeOrHigher` for unions, `parseTypeOperatorOrHigher` for intersections. */
+    parseConstituentType(isUnionType: boolean): TypeNode;
+    parseUnionOrIntersectionType(operator: SyntaxKind): TypeNode;
+    parseTypeOperatorOrHigher(): TypeNode;
+    parseTypeOperator(operator: SyntaxKind): TypeNode;
+    parseInferType(): TypeNode;
+    parseTypeParameterOfInferType(): TypeParameterDeclaration;
+    tryParseConstraintOfInferType(): TypeNode | undefined;
+    parsePostfixTypeOrHigher(): TypeNode;
+    parseNonArrayType(): TypeNode;
+    parseKeywordTypeNode(): TypeNode;
+    parseThisTypeNode(): ThisTypeNode;
+    parseThisTypePredicate(lhs: Node): TypeNode;
+    parseJSDocAllType(): TypeNode;
+    parseJSDocNonNullableType(): TypeNode;
+    parseJSDocNullableType(): TypeNode;
+    parseJSDocType(): TypeNode;
+    parseLiteralTypeNode(negative: boolean): TypeNode;
+    parseTypeReference(): TypeNode;
+    parseEntityNameOfTypeReference(): EntityName;
+    /** An entity name; `use` is for its first identifier, the qualified names' right sides are names. */
+    parseEntityName(allowReservedWords: boolean, diagnosticMessage: DiagnosticMessage | undefined, use?: IdentifierUse): EntityName;
+    parseRightSideOfDot(allowIdentifierNames: boolean, allowPrivateIdentifiers: boolean, allowUnicodeEscapeSequenceInIdentifierName: boolean): Node;
+    /** `parseRightSideOfDot` without private identifiers. */
+    parseRightSideOfDotIdentifier(allowIdentifierNames: boolean, allowUnicodeEscapeSequenceInIdentifierName: boolean): Identifier;
+    /** An identifier or keyword after a line break, followed by another on the same line. */
+    isKeywordStartingNextLine(): boolean;
+    /**
+     * A new identifier of the class `use` calls for. Callers create it after the identifier's token, so
+     * for an element name the current token tells a shorthand property from an assignment or a method.
+     */
+    newIdentifier(text: string, use?: IdentifierUse): Identifier;
+    /** Whether the current token ends an object literal element name that is not a shorthand property. */
+    isElementNameEnd(): boolean;
+    createMissingIdentifier(use?: IdentifierUse): Identifier;
+    parsePrivateIdentifier(): Node;
+    reScanLessThanToken(): SyntaxKind;
+    reScanGreaterThanToken(): SyntaxKind;
+    reScanSlashToken(): SyntaxKind;
+    reScanTemplateToken(isTaggedTemplate: boolean): SyntaxKind;
+    parseTypeArgumentsOfTypeReference(): NodeList | undefined;
+    parseTypeArguments(): NodeList | undefined;
+    parseImportType(): TypeNode;
+    /** Points a trailing `'}' expected.` error at the `{` it should match. */
+    addMatchingBraceRelatedInfo(openBracePosition: number): void;
+    parseImportAttribute(): Node;
+    parseImportAttributes(token: SyntaxKind, skipKeyword: boolean): ImportAttributes;
+    parseTypeQuery(): TypeNode;
+    parseMappedType(): TypeNode;
+    parseMappedTypeParameter(): TypeParameterDeclaration;
+    parseTypeMember(): Node;
+    parseSignatureMember(kind: SyntaxKind): Node;
+    parseTypeParameters(): NodeList | undefined;
+    parseTypeParameter(): Node;
+    parseParameters(flags: ParseFlags): NodeList;
+    /** The parameters, or undefined if `allowAmbiguity` is false and one isn't unambiguously a parameter. */
+    parseParametersWorker(flags: ParseFlags, allowAmbiguity: boolean): NodeList | undefined;
+    parseParameter(): Node;
+    /** The parameter, or `noElement` if ambiguity isn't allowed and no parameter name starts here. */
+    parseParameterEx(inOuterAwaitContext: boolean, allowAmbiguity: boolean): Node;
+    isParameterNameStart(): boolean;
+    parseNameOfParameter(modifiers: ModifierList | undefined): Node;
+    parseReturnType(returnToken: SyntaxKind, isType: boolean): TypeNode | undefined;
+    shouldParseReturnType(returnToken: SyntaxKind, isType: boolean): boolean;
+    parseTypeOrTypePredicate(): TypeNode;
+    /** Type members are separated by commas or (possibly ASI) semicolons. */
+    parseTypeMemberSemicolon(): boolean;
+    parseAccessorDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined, kind: SyntaxKind, flags: ParseFlags): Node;
+    parsePropertyName(use?: IdentifierUse): Node;
+    parsePropertyNameWorker(allowComputedPropertyNames: boolean, use?: IdentifierUse): Node;
+    parseComputedPropertyName(): Node;
+    parseFunctionBlockOrSemicolon(flags: ParseFlags, diagnosticMessage: DiagnosticMessage | undefined): Block | undefined;
+    parseFunctionBlock(flags: ParseFlags, diagnosticMessage: DiagnosticMessage | undefined): Block;
+    isIndexSignature(): boolean;
+    parseIndexSignatureDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Node;
+    parsePropertyOrMethodSignature(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Node;
+    parseTypeLiteral(): TypeNode;
+    parseObjectTypeMembers(): NodeList;
+    parseTupleType(): TypeNode;
+    parseTupleElementNameOrTupleElementType(): Node;
+    parseTupleElementType(): TypeNode;
+    parseParenthesizedType(): TypeNode;
+    parseAssertsTypePredicate(): TypeNode;
+    parseTemplateType(): TypeNode;
+    parseTemplateHead(isTaggedTemplate: boolean): TemplateHead;
+    getTemplateLiteralRawText(endLength: number): string;
+    parseTemplateTypeSpans(): NodeList;
+    parseTemplateTypeSpan(): TemplateLiteralTypeSpan;
+    parseLiteralOfTemplateSpan(isTaggedTemplate: boolean): Node;
+    parseTemplateMiddleOrTail(): Node;
+    /** Function and constructor types must be parenthesized in unions and intersections; parse them with an error. */
+    parseFunctionOrConstructorTypeToError(isInUnionType: boolean): TypeNode;
+    isStartOfFunctionTypeOrConstructorType(): boolean;
+    parseFunctionOrConstructorType(): TypeNode;
+    parseModifiersForConstructorType(): ModifierList | undefined;
+    /** Skips modifiers and a parameter name or binding pattern; true if that succeeded without errors. */
+    skipParameterStart(): boolean;
+    parseModifiers(): ModifierList | undefined;
+    parseModifiersEx(allowDecorators: boolean, permitConstAsModifier: boolean, stopOnStartOfClassStaticBlock: boolean): ModifierList | undefined;
+    parseDecorator(): Node;
+    parseDecoratorExpression(): Expression;
+    tryParseModifier(hasSeenStaticModifier: boolean, permitConstAsModifier: boolean, stopOnStartOfClassStaticBlock: boolean): Node | undefined;
+    parseContextualModifier(t: SyntaxKind): boolean;
+    parseAnyContextualModifier(): boolean;
+    /** Advances past a modifier if the next token can follow it; otherwise leaves the state unchanged. */
+    tryNextTokenCanFollowModifier(): boolean;
+    nextTokenCanFollowModifier(): boolean;
+    nextTokenCanFollowDefaultKeyword(): boolean;
+    canFollowExportModifier(): boolean;
+    canFollowModifier(): boolean;
+    canFollowGetOrSetKeyword(): boolean;
+    nextTokenIsOnSameLineAndCanFollowModifier(): boolean;
+    parseExpression(): Expression;
+    parseExpressionAllowIn(): Expression;
+    parseAssignmentExpressionOrHigher(): Expression;
+    /** `parseAssignmentExpressionOrHigher` with `in` allowed. */
+    parseAssignmentExpressionOrHigherAllowIn(): Expression;
+    parseAssignmentExpressionOrHigherWorker(allowReturnTypeInArrowFunction: boolean): Expression;
+    isYieldExpression(): boolean;
+    parseYieldExpression(): Expression;
+    isParenthesizedArrowFunctionExpression(): Tristate;
+    nextIsParenthesizedArrowFunctionExpression(): Tristate;
+    tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction: boolean): Expression | undefined;
+    parseParenthesizedArrowFunctionExpression(allowAmbiguity: boolean, allowReturnTypeInArrowFunction: boolean): Expression | undefined;
+    parseModifiersForArrowFunction(): ModifierList | undefined;
+    parseArrowFunctionExpressionBody(isAsync: boolean, allowReturnTypeInArrowFunction: boolean): Node;
+    isStartOfExpressionStatement(): boolean;
+    parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction: boolean): Expression | undefined;
+    tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction: boolean): Expression | undefined;
+    parseSimpleArrowFunctionExpression(pos: number, identifier: Node, allowReturnTypeInArrowFunction: boolean, jsdoc: JSDocScannerInfo, asyncModifier: ModifierList | undefined): Expression;
+    parseConditionalExpressionRest(leftOperand: Expression, pos: number, allowReturnTypeInArrowFunction: boolean): Expression;
+    parseBinaryExpressionOrHigher(precedence: OperatorPrecedence): Expression;
+    parseBinaryExpressionRest(precedence: OperatorPrecedence, leftOperand: Expression, pos: number): Expression;
+    makeSatisfiesExpression(expression: Expression, type: TypeNode): Expression;
+    makeAsExpression(left: Expression, right: TypeNode): Expression;
+    makeBinaryExpression(left: Expression, operatorToken: Token, right: Expression, pos: number): Expression;
+    parseUnaryExpressionOrHigher(): Expression;
+    isUpdateExpression(): boolean;
+    parseUpdateExpression(): Expression;
+    parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext: boolean, topInvalidNodePosition: number, openingTag: Node | undefined, mustBeUnary: boolean): Expression;
+    parseJsxChildren(openingTag: Node): NodeList;
+    parseJsxChild(openingTag: Node, token: SyntaxKind): Expression | undefined;
+    parseJsxText(): Node;
+    parseJsxExpression(inExpressionContext: boolean): Node | undefined;
+    scanJsxText(): SyntaxKind;
+    scanJsxIdentifier(): SyntaxKind;
+    scanJsxAttributeValue(): SyntaxKind;
+    parseJsxClosingElement(open: JsxOpeningElement, inExpressionContext: boolean): JsxClosingElement;
+    parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext: boolean): Node;
+    parseJsxElementName(): Expression;
+    parseJsxTagName(): Expression;
+    parseJsxAttributes(): JsxAttributes;
+    parseJsxAttribute(): Node;
+    parseJsxSpreadAttribute(): Node;
+    parseJsxAttributeName(): Node;
+    parseJsxAttributeValue(): Expression | undefined;
+    parseJsxClosingFragment(inExpressionContext: boolean): JsxClosingFragment;
+    parseSimpleUnaryExpression(): Expression;
+    parsePrefixUnaryExpression(): Expression;
+    parseDeleteExpression(): Expression;
+    parseTypeOfExpression(): Expression;
+    parseVoidExpression(): Expression;
+    isAwaitExpression(): boolean;
+    parseAwaitExpression(): Expression;
+    parseTypeAssertion(): Expression;
+    parseLeftHandSideExpressionOrHigher(): Expression;
+    parseSuperExpression(): Expression;
+    isTemplateStartOfTaggedTemplate(): boolean;
+    tryParseTypeArgumentsInExpression(): NodeList | undefined;
+    canFollowTypeArgumentsInExpression(): boolean;
+    parseMemberExpressionOrHigher(): Expression;
+    parseMemberExpressionRest(pos: number, expression: Expression, allowOptionalChain: boolean): Expression;
+    isStartOfOptionalPropertyOrElementAccessChain(): boolean;
+    parsePropertyAccessExpressionRest(pos: number, expression: Expression, questionDotToken: Token | undefined): Expression;
+    tryReparseOptionalChain(node: Expression): boolean;
+    parseElementAccessExpressionRest(pos: number, expression: Expression, questionDotToken: Token | undefined): Expression;
+    parseCallExpressionRest(pos: number, expression: Expression): Expression;
+    parseArgumentList(): NodeList;
+    parseArgumentExpression(): Expression;
+    parseArgumentOrArrayLiteralElement(): Expression;
+    parseSpreadElement(): Expression;
+    parseTaggedTemplateRest(pos: number, tag: Expression, questionDotToken: Token | undefined, typeArguments: NodeList | undefined): Expression;
+    parseTemplateExpression(isTaggedTemplate: boolean): Expression;
+    parseTemplateSpans(isTaggedTemplate: boolean): NodeList;
+    parseTemplateSpan(isTaggedTemplate: boolean): TemplateSpan;
+    parsePrimaryExpression(): Expression;
+    parseParenthesizedExpression(): Expression;
+    parseArrayLiteralExpression(): Expression;
+    parseObjectLiteralExpression(): Expression;
+    parseObjectLiteralElement(): Node;
+    parseFunctionExpression(): Expression;
+    parseOptionalBindingIdentifier(): Identifier | undefined;
+    parseDecoratedExpression(): Expression;
+    /** Re-parents an expression and type arguments first parsed as an ExpressionWithTypeArguments. */
+    unparseExpressionWithTypeArguments(expression: Node, typeArguments: NodeList | undefined, result: Node): void;
+    parseNewExpressionOrNewDotTarget(): Expression;
+    parseKeywordExpression(): Expression;
+    parseLiteralExpression(intern: boolean): Expression;
+    parseIdentifierNameErrorOnUnicodeEscapeSequence(use?: IdentifierUse): Identifier;
+    parseBindingIdentifier(): Identifier;
+    parseBindingIdentifierWithDiagnostic(privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined): Identifier;
+    parseIdentifierName(use?: IdentifierUse): Identifier;
+    parseIdentifierNameWithDiagnostic(diagnosticMessage: DiagnosticMessage | undefined, use?: IdentifierUse): Identifier;
+    parseIdentifier(use?: IdentifierUse): Identifier;
+    parseIdentifierWithDiagnostic(diagnosticMessage: DiagnosticMessage | undefined, privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined, use?: IdentifierUse): Identifier;
+    createIdentifier(isIdentifier: boolean, use?: IdentifierUse): Identifier;
+    createIdentifierWithDiagnostic(isIdentifier: boolean, diagnosticMessage: DiagnosticMessage | undefined, privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined, use?: IdentifierUse): Identifier;
+    internIdentifier(text: string): string;
+    /** Whether the current token can start a signature member, after any modifiers. */
+    scanTypeMemberStart(): boolean;
+    scanClassMemberStart(): boolean;
+    canParseSemicolon(): boolean;
+    tryParseSemicolon(): boolean;
+    parseSemicolon(): boolean;
+    isLiteralPropertyName(): boolean;
+    isStartOfStatement(): boolean;
+    isStartOfDeclaration(): boolean;
+    scanStartOfDeclaration(): boolean;
+    isStartOfExpression(): boolean;
+    isStartOfLeftHandSideExpression(): boolean;
+    isStartOfType(inStartOfParameter: boolean): boolean;
+    isStartOfParameter(isJSDocParameter: boolean): boolean;
+    isBindingIdentifierOrPrivateIdentifierOrPattern(): boolean;
+    isNextTokenOpenParenOrLessThanOrDot(): boolean;
+    nextTokenIsIdentifierOnSameLine(): boolean;
+    nextTokenIsIdentifierOrStringLiteralOnSameLine(): boolean;
+    /** Strict mode reserved words are reported by the checker, not here. */
+    isIdentifier(): boolean;
+    isBindingIdentifier(): boolean;
+    isImportAttributeName(): boolean;
+    isBinaryOperator(): boolean;
+    isValidHeritageClauseObjectLiteral(): boolean;
+    isHeritageClause(): boolean;
+    isHeritageClauseExtendsOrImplementsKeyword(): boolean;
+    isUsingDeclaration(): boolean;
+    nextTokenIsBindingIdentifierOrStartOfDestructuringOnSameLine(disallowOf: boolean): boolean;
+    isAwaitUsingDeclaration(): boolean;
+    checkJSDecoratorSyntax(node: Node): void;
+    /** Reports TypeScript-only syntax in JavaScript files. */
+    checkJSSyntax(node: Node): Node;
+    parseJSONText(): SourceFile;
+    jsonError(node: Node, message: DiagnosticMessage): void;
+    validateJsonValue(sourceFile: SourceFile, value: Node): void;
+    validateJsonObjectLiteral(sourceFile: SourceFile, node: ObjectLiteralExpression): void;
+    processPragmasIntoFields(file: SourceFile): void;
+    parseResolutionMode(mode: string, pos: number, end: number): ModuleKind;
+    /** Whether the members of an object literal are being parsed. */
+    inObjectLiteralMembers(): boolean;
+    /** Enters the JSDoc comment parsing context; returns the previous contexts for restoring. */
+    enterJSDocCommentContext(): number;
+    /** Attaches the JSDoc comments preceding `node`: flags only in TS files (parsed on demand), parsed in JS files. */
+    withJSDoc(node: Node, info: JSDocScannerInfo): void;
+}
+/** The JSDoc nodes of `node`, parsing them on first use in TypeScript files. */
+export declare function getJSDoc(file: SourceFile, node: Node): readonly Node[];
+/**
+ * The JSDoc already attached to `node` (parsed eagerly, or lazily by `getJSDoc`), without parsing:
+ * `undefined` when there is none.
+ */
+export declare function getAttachedJSDoc(node: Node): readonly Node[] | undefined;
+/**
+ * Keeps lazily parsed JSDoc in a table of this thread instead of on the nodes: a program shared with
+ * other threads is never written.
+ */
+export declare function useLazyJSDocTable(): void;
+/** Forgets the file the lazy JSDoc parser last visited. */
+export declare function forgetLazyJSDocFile(): void;
+/** The innermost node containing `position`, stopping at meta properties. */
+export declare function getNodeAtPosition(file: SourceFile, position: number, includeJSDoc: boolean): Node;
+/** Whether `moduleName` names a Node.js core module, with or without the `node:` prefix. */
+export declare function isNodeCoreModule(moduleName: string): boolean;
+export {};