@danielblomma/cortex-mcp 1.3.1 → 1.4.0

package/scaffold/scripts/parsers/node_modules/acorn-typescript/lib/index.d.ts

@@ -0,0 +1,472 @@
+import * as acornNamespace from 'acorn';
+import { Accessibility, LookaheadState, ModifierBase, ParsingContext, TryParse, TsModifier } from './types';
+import { DestructuringErrors } from './parseutil';
+import { AcornParseClass } from './middleware';
+import { Node, TokenType, Position, Options } from 'acorn';
+declare function tsPlugin(options?: {
+    dts?: boolean;
+    jsx?: {
+        allowNamespaces?: boolean;
+        allowNamespacedObjects?: boolean;
+    };
+    allowSatisfies?: boolean;
+}): (Parser: typeof AcornParseClass) => {
+    new (options: Options, input: string, startPos?: number): {
+        preValue: any;
+        preToken: any;
+        isLookahead: boolean;
+        isAmbientContext: boolean;
+        inAbstractClass: boolean;
+        inType: boolean;
+        inDisallowConditionalTypesContext: boolean;
+        maybeInArrowParameters: boolean;
+        shouldParseArrowReturnType: any | undefined;
+        shouldParseAsyncArrowReturnType: any | undefined;
+        decoratorStack: any[];
+        importsStack: any[];
+        /**
+         * we will only parse one import node or export node at same time.
+         * default kind is undefined
+         * */
+        importOrExportOuterKind: string | undefined;
+        tsParseConstModifier: any;
+        readonly acornTypeScript: import("./types").AcornTypeScript;
+        getTokenFromCodeInType(code: number): TokenType;
+        readToken(code: number): any;
+        getTokenFromCode(code: number): TokenType;
+        isAbstractClass(): boolean;
+        finishNode(node: any, type: string): any;
+        tryParse<T extends acornNamespace.Node | readonly acornNamespace.Node[]>(fn: (abort: (node?: T) => never) => T, oldState?: LookaheadState): TryParse<T, null, false, false, null> | TryParse<T, SyntaxError, boolean, false, LookaheadState> | TryParse<T, null, false, true, LookaheadState>;
+        setOptionalParametersError(refExpressionErrors: any, resultError?: any): void;
+        reScan_lt_gt(): void;
+        reScan_lt(): acornNamespace.TokenType;
+        resetEndLocation(node: any, endLoc?: Position): void;
+        startNodeAtNode(type: Node): any;
+        nextTokenStart(): number;
+        tsHasSomeModifiers(member: any, modifiers: readonly TsModifier[]): boolean;
+        tsIsStartOfStaticBlocks(): boolean;
+        tsCheckForInvalidTypeCasts(items: Array<undefined | null | any>): void;
+        atPossibleAsyncArrow(base: any): boolean;
+        tsIsIdentifier(): boolean;
+        tsTryParseTypeOrTypePredicateAnnotation(): acornNamespace.Node;
+        tsTryParseGenericAsyncArrowFunction(startPos: number, startLoc: Position, forInit: boolean): any | undefined | null;
+        tsParseTypeArgumentsInExpression(): Node | void;
+        tsInNoContext<T_1>(cb: () => T_1): T_1;
+        tsTryParseTypeAnnotation(): Node | undefined | null;
+        isUnparsedContextual(nameStart: number, name: string): boolean;
+        isAbstractConstructorSignature(): boolean;
+        nextTokenStartSince(pos: number): number;
+        lookaheadCharCode(): number;
+        compareLookaheadState(state: LookaheadState, state2: LookaheadState): boolean;
+        createLookaheadState(): void;
+        getCurLookaheadState(): LookaheadState;
+        cloneCurLookaheadState(): LookaheadState;
+        setLookaheadState(state: LookaheadState): void;
+        tsLookAhead<T_2>(f: () => T_2): T_2;
+        lookahead(number?: number): LookaheadState;
+        readWord(): any;
+        skipBlockComment(): void;
+        skipLineComment(startSkip: any): void;
+        finishToken(type: TokenType, val?: string): any;
+        resetStartLocation(node: Node, start: number, startLoc: Position): void;
+        isLineTerminator(): boolean;
+        hasFollowingLineBreak(): boolean;
+        addExtra(node: any, key: string, value: any, enumerable?: boolean): void;
+        /**
+         * Test if current token is a literal property name
+         * https://tc39.es/ecma262/#prod-LiteralPropertyName
+         * LiteralPropertyName:
+         *   IdentifierName
+         *   StringLiteral
+         *   NumericLiteral
+         *   BigIntLiteral
+         */
+        isLiteralPropertyName(): boolean;
+        hasPrecedingLineBreak(): boolean;
+        createIdentifier(node: Omit<any, 'type'>, name: string): any;
+        /**
+         * Reset the start location of node to the start location of locationNode
+         */
+        resetStartLocationFromNode(node: Node, locationNode: Node): void;
+        isThisParam(param: any): boolean;
+        isLookaheadContextual(name: string): boolean;
+        /**
+         * ts type isContextual
+         * @param {TokenType} type
+         * @param {TokenType} token
+         * @returns {boolean}
+         * */
+        ts_type_isContextual(type: TokenType, token: TokenType): boolean;
+        /**
+         * ts isContextual
+         * @param {TokenType} token
+         * @returns {boolean}
+         * */
+        ts_isContextual(token: TokenType): boolean;
+        ts_isContextualWithState(state: LookaheadState, token: TokenType): boolean;
+        isContextualWithState(keyword: string, state: LookaheadState): boolean;
+        tsIsStartOfMappedType(): boolean;
+        tsInDisallowConditionalTypesContext<T_3>(cb: () => T_3): T_3;
+        tsTryParseType(): Node | undefined | null;
+        /**
+         * Whether current token matches given type
+         *
+         * @param {TokenType} type
+         * @returns {boolean}
+         * @memberof Tokenizer
+         */
+        match(type: TokenType): boolean;
+        matchJsx(type: string): boolean;
+        ts_eatWithState(type: TokenType, nextCount: number, state: LookaheadState): boolean;
+        ts_eatContextualWithState(name: string, nextCount: number, state: LookaheadState): boolean;
+        canHaveLeadingDecorator(): boolean;
+        eatContextual(name: string): boolean;
+        tsIsExternalModuleReference(): boolean;
+        tsParseExternalModuleReference(): any;
+        tsParseEntityName(allowReservedWords?: boolean): Node;
+        tsParseEnumMember(): Node;
+        tsParseEnumDeclaration(node: any, properties?: {
+            const?: true;
+            declare?: true;
+        }): any;
+        tsParseModuleBlock(): Node;
+        tsParseAmbientExternalModuleDeclaration(node: any): any;
+        tsTryParseDeclare(nany: any): any | undefined | null;
+        tsIsListTerminator(kind: any): boolean;
+        /**
+         * If !expectSuccess, returns undefined instead of failing to parse.
+         * If expectSuccess, parseElement should always return a defined value.
+         */
+        tsParseDelimitedListWorker<T_4 extends acornNamespace.Node>(kind: any, parseElement: () => T_4, expectSuccess: boolean, refTrailingCommaPos?: {
+            value: number;
+        }): T_4[];
+        tsParseDelimitedList<T_5 extends acornNamespace.Node>(kind: any, parseElement: () => T_5, refTrailingCommaPos?: {
+            value: number;
+        }): T_5[];
+        tsParseBracketedList<T_6 extends acornNamespace.Node>(kind: any, parseElement: () => T_6, bracket: boolean, skipFirstToken: boolean, refTrailingCommaPos?: {
+            value: number;
+        }): T_6[];
+        tsParseTypeParameterName(): any | string;
+        tsEatThenParseType(token: TokenType): Node | typeof undefined;
+        tsExpectThenParseType(token: TokenType): Node;
+        tsNextThenParseType(): Node;
+        tsDoThenParseType(cb: () => void): Node;
+        tsSkipParameterStart(): boolean;
+        tsIsUnambiguouslyStartOfFunctionType(): boolean;
+        tsIsStartOfFunctionType(): unknown;
+        tsInAllowConditionalTypesContext<T_7>(cb: () => T_7): T_7;
+        tsParseBindingListForSignature(): Array<any>;
+        tsParseTypePredicateAsserts(): boolean;
+        tsParseThisTypeNode(): any;
+        tsParseTypeAnnotation(eatColon?: boolean, t?: any): any;
+        tsParseThisTypePredicate(lhs: any): any;
+        tsParseThisTypeOrThisTypePredicate(): any;
+        tsParseTypePredicatePrefix(): any | undefined | null;
+        tsParseTypeOrTypePredicateAnnotation(returnToken: TokenType): Node;
+        tsFillSignature(returnToken: TokenType, signature: any): void;
+        tsTryNextParseConstantContext(): Node | undefined | null;
+        tsParseFunctionOrConstructorType(type: 'TSFunctionType' | 'TSConstructorType', abstract?: boolean): any;
+        tsParseUnionOrIntersectionType(kind: 'TSUnionType' | 'TSIntersectionType', parseConstituentType: () => Node, operator: TokenType): Node;
+        tsCheckTypeAnnotationForReadOnly(node: any): void;
+        tsParseTypeOperator(): any;
+        tsParseConstraintForInferType(): any;
+        tsParseInferType(): any;
+        tsParseLiteralTypeNode(): any;
+        tsParseImportType(): any;
+        tsParseTypeQuery(): any;
+        tsParseMappedTypeParameter(): any;
+        tsParseMappedType(): any;
+        tsParseTypeLiteral(): Node;
+        tsParseTupleElementType(): any;
+        tsParseTupleType(): any;
+        tsParseTemplateLiteralType(): any;
+        tsParseTypeReference(): any;
+        tsMatchLeftRelational(): boolean;
+        tsMatchRightRelational(): boolean;
+        tsParseParenthesizedType(): any;
+        tsParseNonArrayType(): Node;
+        tsParseArrayTypeOrHigher(): Node;
+        tsParseTypeOperatorOrHigher(): Node;
+        tsParseIntersectionTypeOrHigher(): Node;
+        tsParseUnionTypeOrHigher(): acornNamespace.Node;
+        tsParseNonConditionalType(): any;
+        /** Be sure to be in a type context before calling this, using `tsInType`. */
+        tsParseType(): any;
+        tsIsUnambiguouslyIndexSignature(): boolean;
+        /**
+         * Runs `cb` in a type context.
+         * This should be called one token *before* the first type token,
+         * so that the call to `next()` is run in type context.
+         */
+        tsInType<T_8>(cb: () => T_8): T_8;
+        tsTryParseIndexSignature(node: any): any | undefined | null;
+        tsParseNoneModifiers(node: any): void;
+        tsParseTypeParameter(parseModifiers?: (node: Node) => void): Node;
+        tsParseTypeParameters(parseModifiers?: (node: any) => void): any;
+        tsTryParseTypeParameters(parseModifiers?: (node: any) => void): any;
+        tsTryParse<T_9>(f: () => false | T_9): T_9;
+        tsTokenCanFollowModifier(): boolean;
+        tsNextTokenCanFollowModifier(): boolean;
+        /** Parses a modifier matching one the given modifier names. */
+        tsParseModifier<T_10 extends TsModifier>(allowedModifiers: T_10[], stopOnStartOfClassStaticBlock?: boolean): T_10;
+        tsParseModifiersByMap({ modified, map }: {
+            modified: ModifierBase;
+            map: Record<string, any>;
+        }): void;
+        /** Parses a list of modifiers, in any order.
+         *  If you need a specific order, you must call this function multiple times:
+         *    this.tsParseModifiers({ modified: node, allowedModifiers: ['public'] });
+         *    this.tsParseModifiers({ modified: node, allowedModifiers: ["abstract", "readonly"] });
+         */
+        tsParseModifiers({ modified, allowedModifiers, disallowedModifiers, stopOnStartOfClassStaticBlock, errorTemplate }: {
+            modified: ModifierBase;
+            allowedModifiers: readonly TsModifier[];
+            disallowedModifiers?: TsModifier[];
+            stopOnStartOfClassStaticBlock?: boolean;
+            errorTemplate?: any;
+        }): Record<string, any>;
+        tsParseInOutModifiers(node: any): void;
+        tsParseTypeArguments(): any;
+        tsParseHeritageClause(token: 'extends' | 'implements'): Array<any>;
+        tsParseTypeMemberSemicolon(): void;
+        tsTryParseAndCatch<T_11 extends unknown>(f: () => T_11): T_11;
+        tsParseSignatureMember(kind: 'TSCallSignatureDeclaration' | 'TSConstructSignatureDeclaration', node: Node): Node;
+        tsParsePropertyOrMethodSignature(node: any, readonly: boolean): any;
+        tsParseTypeMember(): any;
+        tsParseList<T_12 extends acornNamespace.Node>(kind: ParsingContext, parseElement: () => T_12): T_12[];
+        tsParseObjectTypeMembers(): Array<Node>;
+        tsParseInterfaceDeclaration(node: any, properties?: {
+            declare?: true;
+        }): any | undefined | null;
+        tsParseAbstractDeclaration(node: any): any | undefined | null;
+        tsIsDeclarationStart(): boolean;
+        tsParseExpressionStatement(node: any, expr: any): any;
+        tsParseModuleReference(): any;
+        tsIsExportDefaultSpecifier(): boolean;
+        tsInAmbientContext<T_13>(cb: () => T_13): T_13;
+        tsCheckLineTerminator(next: boolean): boolean;
+        tsParseModuleOrNamespaceDeclaration(node: any, nested?: boolean): any;
+        checkLValSimple(expr: any, bindingType?: any, checkClashes?: any): any;
+        tsParseTypeAliasDeclaration(node: any): any;
+        tsParseDeclaration(node: any, value: string, next: boolean): any | undefined | null;
+        tsTryParseExportDeclaration(): any | undefined | null;
+        tsParseImportEqualsDeclaration(node: any, isExport?: boolean): Node;
+        isExportDefaultSpecifier(): boolean;
+        parseTemplate({ isTagged }?: {
+            isTagged?: boolean;
+        }): any;
+        parseFunction(node: any, statement?: number, allowExpressionBody?: boolean, isAsync?: boolean, forInit?: boolean): any;
+        parseFunctionBody(node: any, isArrowFunction?: boolean, isMethod?: boolean, forInit?: boolean, tsConfig?: {
+            isFunctionDeclaration?: boolean;
+            isClassMethod?: boolean;
+        }): any;
+        parseNew(): any;
+        parseExprOp(left: any, leftStartPos: number, leftStartLoc: Position, minPrec: number, forInit: boolean): any;
+        parseImportSpecifiers(): any[];
+        /**
+         * @param {Node} node this may be ImportDeclaration |
+         * TsImportEqualsDeclaration
+         * @returns AnyImport
+         * */
+        parseImport(node: any): any;
+        parseExportDefaultDeclaration(): any;
+        parseExportAllDeclaration(node: any, exports: any): any;
+        parseDynamicImport(node: any): any;
+        parseExport(node: any, exports: any): any;
+        checkExport(exports: any, name: any, _: any): void;
+        parseMaybeDefault(startPos?: number | null, startLoc?: Position | null, left?: any | null): any;
+        typeCastToParameter(node: any): any;
+        toAssignableList(exprList: any[], isBinding: boolean): any;
+        reportReservedArrowTypeParam(node: any): void;
+        parseExprAtom(refDestructuringErrors?: DestructuringErrors, forInit?: boolean, forNew?: boolean): any;
+        parseExprAtomDefault(): any;
+        parseIdentNode(): any;
+        parseVarStatement(node: any, kind: any, allowMissingInitializer?: boolean): any;
+        parseStatement(context: any, topLevel?: any, exports?: any): any;
+        parseAccessModifier(): Accessibility | undefined | null;
+        parsePostMemberNameModifiers(methodOrProp: any): void;
+        parseExpressionStatement(node: any, expr: any): any;
+        shouldParseExportStatement(): boolean;
+        parseConditional(expr: any, startPos: number, startLoc: Position, forInit?: boolean, refDestructuringErrors?: any): any;
+        parseMaybeConditional(forInit: any, refDestructuringErrors: any): any;
+        parseParenItem(node: any): any;
+        parseExportDeclaration(node: any): any | undefined | null;
+        parseClassId(node: any, isStatement: boolean | 'nullableID'): void;
+        parseClassPropertyAnnotation(node: any): void;
+        parseClassField(field: any): any;
+        parseClassMethod(method: any, isGenerator: any, isAsync: any, allowsDirectSuper: any): any;
+        isClassMethod(): boolean;
+        parseClassElement(constructorAllowsSuper: any): any;
+        isClassElementNameStart(): boolean;
+        parseClassSuper(node: any): void;
+        parseFunctionParams(node: any): void;
+        parseVarId(decl: any, kind: 'var' | 'let' | 'const'): void;
+        parseArrowExpression(node: any, params: any[], isAsync: boolean, forInit?: boolean): any;
+        parseMaybeAssignOrigin(forInit?: any, refDestructuringErrors?: any | null, afterLeftParse?: any): any;
+        parseMaybeAssign(forInit?: boolean, refExpressionErrors?: any | null, afterLeftParse?: any): any;
+        parseAssignableListItem(allowModifiers: boolean | undefined | null): any;
+        checkLValInnerPattern(expr: any, bindingType: number, checkClashes: any): void;
+        parseBindingListItem(param: any): any;
+        isAssignable(node: any, isBinding?: boolean): boolean;
+        toAssignable(node: any, isBinding?: boolean, refDestructuringErrors?: DestructuringErrors): any;
+        toAssignableParenthesizedExpression(node: any, isBinding: boolean, refDestructuringErrors: DestructuringErrors): void;
+        curPosition(): acornNamespace.Position;
+        parseBindingAtom(): any;
+        shouldParseArrow(exprList?: any): boolean;
+        parseParenArrowList(startPos: any, startLoc: any, exprList: any, forInit: any): any;
+        parseParenAndDistinguishExpression(canBeArrow: any, forInit: any): any;
+        parseTaggedTemplateExpression(base: any, startPos: number, startLoc: Position, optionalChainMember: boolean): any;
+        shouldParseAsyncArrow(): boolean;
+        parseSubscriptAsyncArrow(startPos: any, startLoc: any, exprList: any, forInit: any): any;
+        parseExprList(close: TokenType, allowTrailingComma?: any, allowEmpty?: any, refDestructuringErrors?: any): any[];
+        parseSubscript(base: any, startPos: any, startLoc: any, noCalls: any, maybeAsyncArrow: any, optionalChained: any, forInit: any): any;
+        parseGetterSetter(prop: any): void;
+        parseProperty(isPattern: any, refDestructuringErrors: any): any;
+        parseCatchClauseParam(): any;
+        parseClass(node: any, isStatement: boolean | 'nullableID'): any;
+        parseClassFunctionParams(): any;
+        parseMethod(isGenerator: boolean, isAsync?: boolean, allowDirectSuper?: boolean, inClassScope?: boolean, method?: any): any;
+        parseImportSpecifier(): any;
+        parseExportSpecifier(exports: any): any;
+        parseTypeOnlyImportExportSpecifier(node: any, isImport: boolean, isInTypeOnlyImportExport: boolean): void;
+        raiseCommonCheck(pos: number, message: string, recoverable: boolean): void;
+        raiseRecoverable(pos: number, message: string): void;
+        raise(pos: number, message: string): void;
+        updateContext(prevType: any): any;
+        jsx_parseOpeningElementAt(startPos: any, startLoc: any): any;
+        enterScope(flags: any): void;
+        exitScope(): void;
+        hasImport(name: string, allowShadow?: boolean): boolean;
+        maybeExportDefined(scope: any, name: string): void;
+        isRedeclaredInScope(scope: any, name: string, bindingType: any): boolean;
+        checkRedeclarationInScope(scope: any, name: string, bindingType: any, loc: any): void;
+        declareName(name: any, bindingType: any, pos: any): void;
+        checkLocalExport(id: any): void;
+        options: acornNamespace.Options & {
+            onComment: any;
+        };
+        pos: number;
+        potentialArrowAt: number;
+        yieldPos: number;
+        value: any;
+        containsEsc: boolean;
+        awaitPos: number;
+        keywords: any;
+        awaitIdentPos: number;
+        strict: boolean;
+        lastTokStart: number;
+        lastTokEnd: number;
+        treatFunctionsAsVar: boolean;
+        inGenerator: any;
+        exprAllowed: boolean;
+        labels: any[];
+        scopeStack: any[];
+        inModule: any;
+        undefinedExports: any;
+        lastTokEndLoc: any;
+        lastTokStartLoc: any;
+        context: any[];
+        endLoc: any;
+        startLoc: any;
+        potentialArrowInForAwait: boolean;
+        currentScope(): any;
+        treatFunctionsAsVarInScope(scope: any): boolean;
+        parseExportSpecifiers(exports: any): any[];
+        parseModuleExportName(): any;
+        expectContextual(name: string): any;
+        semicolon(): any;
+        eat(type: acornNamespace.TokenType): boolean;
+        unexpected(pos?: number): any;
+        startNode(): any;
+        startNodeAt(pos: number, loc: any): any;
+        isAsyncFunction(): boolean;
+        checkVariableExport(exports: any, decls: any): any;
+        checkUnreserved(options: {
+            start: number;
+            end: number;
+            name: string;
+        }): any;
+        finishOp(type: acornNamespace.TokenType, size: number): any;
+        readToken_lt_gt(code: number): acornNamespace.TokenType;
+        fullCharCodeAtPos(): number;
+        canInsertSemicolon(): boolean;
+        expect(type: acornNamespace.TokenType): void;
+        readWord1(): string;
+        curContext(): any;
+        isContextual(name: string): boolean;
+        parseLiteral(value: string): any;
+        parseFunctionStatement(node: any, isAsync?: boolean, declarationPosition?: any): any;
+        parseObj(isPattern?: boolean, refDestructuringErrors?: any): any;
+        parseBindingList(close: acornNamespace.TokenType, allowEmpty?: boolean, allowTrailingComma?: boolean, allowModifiers?: boolean): any;
+        parsePropertyName(prop: any): any;
+        isLet(context?: any): boolean;
+        parseTemplateElement({ isTagged }: {
+            isTagged: boolean;
+        }): any;
+        parseExpression(forInit?: boolean, refDestructuringErrors?: any): any;
+        initFunction(node: any): void;
+        parseSubscripts(base: any, startPos: number, startLoc: acornNamespace.Position, noCalls?: any, forInit?: any): any;
+        parseSpread(refDestructuringErrors: any): any;
+        parseMaybeUnary(refExpressionErrors?: any, sawUnary?: boolean, incDec?: boolean, forInit?: boolean): any;
+        readRegexp(): any;
+        overrideContext(ctx: any): any;
+        isSimpleAssignTarget(expr: any): boolean;
+        parseExprImport(forNew?: boolean): any;
+        next(ignoreEscapeSequenceInKeyword?: boolean): any;
+        parseExprOps(forInit?: boolean, refDestructuringErrors?: any): any;
+        checkExpressionErrors(refDestructuringErrors: any, andThrow?: boolean): any;
+        parseClassStaticBlock(node: any): any;
+        parseClassElementName(element: any): any;
+        checkPatternErrors(refDestructuringErrors?: any, isAssign?: boolean): any;
+        parseExprSubscripts(refDestructuringErrors?: any, forInit?: boolean): any;
+        checkYieldAwaitInDefaultParams(): any;
+        parseParenExpression(): any;
+        afterTrailingComma(tokType: acornNamespace.TokenType, notNext?: boolean): any;
+        parsePrivateIdent(): any;
+        parseRestBinding(): any;
+        parseBlock(createNewLexicalScope?: boolean, node?: any, exitStrict?: boolean): any;
+        enterClassBody(): any;
+        exitClassBody(): any;
+        parseVar(node: any, isFor: any, kind: any, allowMissingInitializer: any): any;
+        parseIdent(liberal?: boolean): any;
+        copyNode(node: any): any;
+        checkLValPattern(expr: any, bindingType?: number, checkClashes?: any): any;
+        isAsyncProp(prop: any): boolean;
+        parseYield(forInit?: any): any;
+        takeDecorators(node: any): void;
+        parseDecorators(allowExport?: boolean): void;
+        parseDecorator(): any;
+        parseMaybeDecoratorArguments(expr: any): any;
+        jsx_readToken(): any;
+        jsx_readString(quote: any): any;
+        jsx_parseText(): any;
+        jsx_parseElement(): any;
+        jsx_readWord(): any;
+        jsx_parseElementName(): any;
+        jsx_parseAttribute(): any;
+        parseImportDefaultSpecifier(): any;
+        parseImportNamespaceSpecifier(): any;
+        parseImportAttributes(): any;
+        parseMaybeImportAttributes(node: any): any;
+        lineStart: number;
+        curLine: number;
+        start: number;
+        end: number;
+        input: string;
+        type: acornNamespace.TokenType;
+        parse(this: acornNamespace.Parser): acornNamespace.Node;
+        nextToken(): void;
+        parseTopLevel(node: acornNamespace.Node): acornNamespace.Node;
+        finishNodeAt(node: acornNamespace.Node, type: string, pos: number, loc: acornNamespace.Position): acornNamespace.Node;
+    };
+    readonly acornTypeScript: import("./types").AcornTypeScript;
+    parse(input: string, options: Options): acornNamespace.Node;
+    parseExpressionAt(input: string, pos: number, options: Options): any;
+    acorn: typeof acornNamespace;
+    tokenizer(this: typeof acornNamespace.Parser, input: string, options: acornNamespace.Options): {
+        getToken(): acornNamespace.Token;
+        [Symbol.iterator](): Iterator<acornNamespace.Token, any, undefined>;
+    };
+    extend(this: typeof acornNamespace.Parser, ...plugins: ((BaseParser: typeof acornNamespace.Parser) => typeof acornNamespace.Parser)[]): typeof acornNamespace.Parser;
+};
+export { tsPlugin as default, tsPlugin };