Interface NodeFactory

interface NodeFactory {
    createAdd(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createArrayBindingPattern(
        elements: readonly tsc.ArrayBindingElement[],
    ): tsc.ArrayBindingPattern;
    createArrayLiteralExpression(
        elements?: readonly tsc.Expression[],
        multiLine?: boolean,
    ): tsc.ArrayLiteralExpression;
    createArrayTypeNode(elementType: tsc.TypeNode): tsc.ArrayTypeNode;
    createArrowFunction(
        modifiers: readonly Modifier[] | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
        equalsGreaterThanToken: EqualsGreaterThanToken | undefined,
        body: ConciseBody,
    ): tsc.ArrowFunction;
    createAsExpression(
        expression: tsc.Expression,
        type: tsc.TypeNode,
    ): tsc.AsExpression;
    createAssertClause(
        elements: NodeArray<AssertEntry>,
        multiLine?: boolean,
    ): AssertClause;
    createAssertEntry(
        name: ImportAttributeName,
        value: tsc.Expression,
    ): AssertEntry;
    createAssignment(
        left: tsc.ObjectLiteralExpression | tsc.ArrayLiteralExpression,
        right: tsc.Expression,
    ): DestructuringAssignment;
    createAssignment(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.AssignmentExpression<EqualsToken>;
    createAwaitExpression(expression: tsc.Expression): tsc.AwaitExpression;
    createBigIntLiteral(value: string | PseudoBigInt): tsc.BigIntLiteral;
    createBinaryExpression(
        left: tsc.Expression,
        operator: BinaryOperatorToken | BinaryOperator,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createBindingElement(
        dotDotDotToken: DotDotDotToken | undefined,
        propertyName: string | tsc.PropertyName | undefined,
        name: string | tsc.BindingName,
        initializer?: tsc.Expression,
    ): tsc.BindingElement;
    createBitwiseAnd(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createBitwiseNot(operand: tsc.Expression): tsc.PrefixUnaryExpression;
    createBitwiseOr(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createBitwiseXor(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createBlock(
        statements: readonly tsc.Statement[],
        multiLine?: boolean,
    ): tsc.Block;
    createBreakStatement(label?: string | tsc.Identifier): tsc.BreakStatement;
    createBundle(sourceFiles: readonly tsc.SourceFile[]): Bundle;
    createCallChain(
        expression: tsc.Expression,
        questionDotToken: QuestionDotToken | undefined,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        argumentsArray: readonly tsc.Expression[] | undefined,
    ): CallChain;
    createCallExpression(
        expression: tsc.Expression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        argumentsArray: readonly tsc.Expression[] | undefined,
    ): tsc.CallExpression;
    createCallSignature(
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
    ): tsc.CallSignatureDeclaration;
    createCaseBlock(clauses: readonly tsc.CaseOrDefaultClause[]): tsc.CaseBlock;
    createCaseClause(
        expression: tsc.Expression,
        statements: readonly tsc.Statement[],
    ): tsc.CaseClause;
    createCatchClause(
        variableDeclaration:
            | string
            | tsc.BindingName
            | tsc.VariableDeclaration
            | undefined,
        block: tsc.Block,
    ): tsc.CatchClause;
    createClassDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        name: string | tsc.Identifier | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        heritageClauses: readonly tsc.HeritageClause[] | undefined,
        members: readonly tsc.ClassElement[],
    ): tsc.ClassDeclaration;
    createClassExpression(
        modifiers: readonly ModifierLike[] | undefined,
        name: string | tsc.Identifier | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        heritageClauses: readonly tsc.HeritageClause[] | undefined,
        members: readonly tsc.ClassElement[],
    ): tsc.ClassExpression;
    createClassStaticBlockDeclaration(
        body: tsc.Block,
    ): tsc.ClassStaticBlockDeclaration;
    createComma(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createCommaListExpression(
        elements: readonly tsc.Expression[],
    ): tsc.CommaListExpression;
    createComputedPropertyName(
        expression: tsc.Expression,
    ): tsc.ComputedPropertyName;
    createConditionalExpression(
        condition: tsc.Expression,
        questionToken: QuestionToken | undefined,
        whenTrue: tsc.Expression,
        colonToken: ColonToken | undefined,
        whenFalse: tsc.Expression,
    ): tsc.ConditionalExpression;
    createConditionalTypeNode(
        checkType: tsc.TypeNode,
        extendsType: tsc.TypeNode,
        trueType: tsc.TypeNode,
        falseType: tsc.TypeNode,
    ): tsc.ConditionalTypeNode;
    createConstructorDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        body: tsc.Block | undefined,
    ): tsc.ConstructorDeclaration;
    createConstructorTypeNode(
        modifiers: readonly Modifier[] | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode,
    ): tsc.ConstructorTypeNode;
    createConstructSignature(
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
    ): tsc.ConstructSignatureDeclaration;
    createContinueStatement(
        label?: string | tsc.Identifier,
    ): tsc.ContinueStatement;
    createDebuggerStatement(): tsc.DebuggerStatement;
    createDecorator(expression: tsc.Expression): tsc.Decorator;
    createDefaultClause(
        statements: readonly tsc.Statement[],
    ): tsc.DefaultClause;
    createDeleteExpression(expression: tsc.Expression): tsc.DeleteExpression;
    createDivide(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createDoStatement(
        statement: tsc.Statement,
        expression: tsc.Expression,
    ): tsc.DoStatement;
    createElementAccessChain(
        expression: tsc.Expression,
        questionDotToken: QuestionDotToken | undefined,
        index: number | tsc.Expression,
    ): ElementAccessChain;
    createElementAccessExpression(
        expression: tsc.Expression,
        index: number | tsc.Expression,
    ): tsc.ElementAccessExpression;
    createEmptyStatement(): tsc.EmptyStatement;
    createEnumDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        name: string | tsc.Identifier,
        members: readonly tsc.EnumMember[],
    ): tsc.EnumDeclaration;
    createEnumMember(
        name: string | tsc.PropertyName,
        initializer?: tsc.Expression,
    ): tsc.EnumMember;
    createEquality(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createExponent(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createExportAssignment(
        modifiers: readonly ModifierLike[] | undefined,
        isExportEquals: boolean | undefined,
        expression: tsc.Expression,
    ): tsc.ExportAssignment;
    createExportDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        isTypeOnly: boolean,
        exportClause: NamedExportBindings | undefined,
        moduleSpecifier?: tsc.Expression,
        attributes?: tsc.ImportAttributes,
    ): tsc.ExportDeclaration;
    createExportDefault(expression: tsc.Expression): tsc.ExportAssignment;
    createExportSpecifier(
        isTypeOnly: boolean,
        propertyName: string | tsc.Identifier | undefined,
        name: string | tsc.Identifier,
    ): tsc.ExportSpecifier;
    createExpressionStatement(
        expression: tsc.Expression,
    ): tsc.ExpressionStatement;
    createExpressionWithTypeArguments(
        expression: tsc.Expression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
    ): tsc.ExpressionWithTypeArguments;
    createExternalModuleExport(
        exportName: tsc.Identifier,
    ): tsc.ExportDeclaration;
    createExternalModuleReference(
        expression: tsc.Expression,
    ): tsc.ExternalModuleReference;
    createFalse(): tsc.FalseLiteral;
    createForInStatement(
        initializer: ForInitializer,
        expression: tsc.Expression,
        statement: tsc.Statement,
    ): tsc.ForInStatement;
    createForOfStatement(
        awaitModifier: AwaitKeyword | undefined,
        initializer: ForInitializer,
        expression: tsc.Expression,
        statement: tsc.Statement,
    ): tsc.ForOfStatement;
    createForStatement(
        initializer: ForInitializer | undefined,
        condition: tsc.Expression | undefined,
        incrementor: tsc.Expression | undefined,
        statement: tsc.Statement,
    ): tsc.ForStatement;
    createFunctionDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        asteriskToken: AsteriskToken | undefined,
        name: string | tsc.Identifier | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
        body: tsc.Block | undefined,
    ): tsc.FunctionDeclaration;
    createFunctionExpression(
        modifiers: readonly Modifier[] | undefined,
        asteriskToken: AsteriskToken | undefined,
        name: string | tsc.Identifier | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[] | undefined,
        type: tsc.TypeNode | undefined,
        body: tsc.Block,
    ): tsc.FunctionExpression;
    createFunctionTypeNode(
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode,
    ): tsc.FunctionTypeNode;
    createGetAccessorDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        name: string | tsc.PropertyName,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
        body: tsc.Block | undefined,
    ): tsc.GetAccessorDeclaration;
    createGreaterThan(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createGreaterThanEquals(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createHeritageClause(
        token: ExtendsKeyword | ImplementsKeyword,
        types: readonly tsc.ExpressionWithTypeArguments[],
    ): tsc.HeritageClause;
    createIdentifier(text: string): tsc.Identifier;
    createIfStatement(
        expression: tsc.Expression,
        thenStatement: tsc.Statement,
        elseStatement?: tsc.Statement,
    ): tsc.IfStatement;
    createImmediatelyInvokedArrowFunction(
        statements: readonly tsc.Statement[],
    ): ImmediatelyInvokedArrowFunction;
    createImmediatelyInvokedArrowFunction(
        statements: readonly tsc.Statement[],
        param: tsc.ParameterDeclaration,
        paramValue: tsc.Expression,
    ): ImmediatelyInvokedArrowFunction;
    createImmediatelyInvokedFunctionExpression(
        statements: readonly tsc.Statement[],
    ): tsc.CallExpression;
    createImmediatelyInvokedFunctionExpression(
        statements: readonly tsc.Statement[],
        param: tsc.ParameterDeclaration,
        paramValue: tsc.Expression,
    ): tsc.CallExpression;
    createImportAttribute(
        name: ImportAttributeName,
        value: tsc.Expression,
    ): tsc.ImportAttribute;
    createImportAttributes(
        elements: NodeArray<tsc.ImportAttribute>,
        multiLine?: boolean,
    ): tsc.ImportAttributes;
    createImportClause(
        isTypeOnly: boolean,
        name: tsc.Identifier | undefined,
        namedBindings: NamedImportBindings | undefined,
    ): tsc.ImportClause;
    createImportDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        importClause: tsc.ImportClause | undefined,
        moduleSpecifier: tsc.Expression,
        attributes?: tsc.ImportAttributes,
    ): tsc.ImportDeclaration;
    createImportEqualsDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        isTypeOnly: boolean,
        name: string | tsc.Identifier,
        moduleReference: tsc.ModuleReference,
    ): tsc.ImportEqualsDeclaration;
    createImportSpecifier(
        isTypeOnly: boolean,
        propertyName: tsc.Identifier | undefined,
        name: tsc.Identifier,
    ): tsc.ImportSpecifier;
    createImportTypeAssertionContainer(
        clause: AssertClause,
        multiLine?: boolean,
    ): ImportTypeAssertionContainer;
    createImportTypeNode(
        argument: tsc.TypeNode,
        attributes?: tsc.ImportAttributes,
        qualifier?: tsc.EntityName,
        typeArguments?: readonly tsc.TypeNode[],
        isTypeOf?: boolean,
    ): tsc.ImportTypeNode;
    createIndexedAccessTypeNode(
        objectType: tsc.TypeNode,
        indexType: tsc.TypeNode,
    ): tsc.IndexedAccessTypeNode;
    createIndexSignature(
        modifiers: readonly ModifierLike[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode,
    ): tsc.IndexSignatureDeclaration;
    createInequality(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createInferTypeNode(
        typeParameter: tsc.TypeParameterDeclaration,
    ): tsc.InferTypeNode;
    createInterfaceDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        name: string | tsc.Identifier,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        heritageClauses: readonly tsc.HeritageClause[] | undefined,
        members: readonly tsc.TypeElement[],
    ): tsc.InterfaceDeclaration;
    createIntersectionTypeNode(
        types: readonly tsc.TypeNode[],
    ): tsc.IntersectionTypeNode;
    createJSDocAllType(): tsc.JSDocAllType;
    createJSDocAugmentsTag(
        tagName: tsc.Identifier | undefined,
        className: tsc.ExpressionWithTypeArguments & {
            expression: tsc.Identifier | PropertyAccessEntityNameExpression;
        },
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocAugmentsTag;
    createJSDocAuthorTag(
        tagName: tsc.Identifier | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocAuthorTag;
    createJSDocCallbackTag(
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocSignature,
        fullName?: tsc.Identifier | JSDocNamespaceDeclaration,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocCallbackTag;
    createJSDocClassTag(
        tagName: tsc.Identifier | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocClassTag;
    createJSDocComment(
        comment?: string | NodeArray<JSDocComment>,
        tags?: readonly tsc.JSDocTag[],
    ): tsc.JSDoc;
    createJSDocDeprecatedTag(
        tagName: tsc.Identifier | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocDeprecatedTag;
    createJSDocEnumTag(
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocEnumTag;
    createJSDocFunctionType(
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
    ): tsc.JSDocFunctionType;
    createJSDocImplementsTag(
        tagName: tsc.Identifier | undefined,
        className: tsc.ExpressionWithTypeArguments & {
            expression: tsc.Identifier | PropertyAccessEntityNameExpression;
        },
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocImplementsTag;
    createJSDocImportTag(
        tagName: tsc.Identifier | undefined,
        importClause: tsc.ImportClause | undefined,
        moduleSpecifier: tsc.Expression,
        attributes?: tsc.ImportAttributes,
        comment?: string | NodeArray<JSDocComment>,
    ): JSDocImportTag;
    createJSDocLink(
        name: tsc.JSDocMemberName | tsc.EntityName | undefined,
        text: string,
    ): tsc.JSDocLink;
    createJSDocLinkCode(
        name: tsc.JSDocMemberName | tsc.EntityName | undefined,
        text: string,
    ): tsc.JSDocLinkCode;
    createJSDocLinkPlain(
        name: tsc.JSDocMemberName | tsc.EntityName | undefined,
        text: string,
    ): tsc.JSDocLinkPlain;
    createJSDocMemberName(
        left: tsc.JSDocMemberName | tsc.EntityName,
        right: tsc.Identifier,
    ): tsc.JSDocMemberName;
    createJSDocNamepathType(type: tsc.TypeNode): tsc.JSDocNamepathType;
    createJSDocNameReference(
        name: tsc.JSDocMemberName | tsc.EntityName,
    ): tsc.JSDocNameReference;
    createJSDocNonNullableType(
        type: tsc.TypeNode,
        postfix?: boolean,
    ): tsc.JSDocNonNullableType;
    createJSDocNullableType(
        type: tsc.TypeNode,
        postfix?: boolean,
    ): tsc.JSDocNullableType;
    createJSDocOptionalType(type: tsc.TypeNode): tsc.JSDocOptionalType;
    createJSDocOverloadTag(
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocSignature,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocOverloadTag;
    createJSDocOverrideTag(
        tagName: tsc.Identifier | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocOverrideTag;
    createJSDocParameterTag(
        tagName: tsc.Identifier | undefined,
        name: tsc.EntityName,
        isBracketed: boolean,
        typeExpression?: tsc.JSDocTypeExpression,
        isNameFirst?: boolean,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocParameterTag;
    createJSDocPrivateTag(
        tagName: tsc.Identifier | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocPrivateTag;
    createJSDocPropertyTag(
        tagName: tsc.Identifier | undefined,
        name: tsc.EntityName,
        isBracketed: boolean,
        typeExpression?: tsc.JSDocTypeExpression,
        isNameFirst?: boolean,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocPropertyTag;
    createJSDocProtectedTag(
        tagName: tsc.Identifier | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocProtectedTag;
    createJSDocPublicTag(
        tagName: tsc.Identifier | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocPublicTag;
    createJSDocReadonlyTag(
        tagName: tsc.Identifier | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocReadonlyTag;
    createJSDocReturnTag(
        tagName: tsc.Identifier | undefined,
        typeExpression?: tsc.JSDocTypeExpression,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocReturnTag;
    createJSDocSatisfiesTag(
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocSatisfiesTag;
    createJSDocSeeTag(
        tagName: tsc.Identifier | undefined,
        nameExpression: tsc.JSDocNameReference | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocSeeTag;
    createJSDocSignature(
        typeParameters: readonly tsc.JSDocTemplateTag[] | undefined,
        parameters: readonly tsc.JSDocParameterTag[],
        type?: tsc.JSDocReturnTag,
    ): tsc.JSDocSignature;
    createJSDocTemplateTag(
        tagName: tsc.Identifier | undefined,
        constraint: tsc.JSDocTypeExpression | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[],
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocTemplateTag;
    createJSDocText(text: string): tsc.JSDocText;
    createJSDocThisTag(
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocThisTag;
    createJSDocThrowsTag(
        tagName: tsc.Identifier,
        typeExpression: tsc.JSDocTypeExpression | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocThrowsTag;
    createJSDocTypedefTag(
        tagName: tsc.Identifier | undefined,
        typeExpression?: tsc.JSDocTypeExpression | tsc.JSDocTypeLiteral,
        fullName?: tsc.Identifier | JSDocNamespaceDeclaration,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocTypedefTag;
    createJSDocTypeExpression(type: tsc.TypeNode): tsc.JSDocTypeExpression;
    createJSDocTypeLiteral(
        jsDocPropertyTags?: readonly tsc.JSDocPropertyLikeTag[],
        isArrayType?: boolean,
    ): tsc.JSDocTypeLiteral;
    createJSDocTypeTag(
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocTypeTag;
    createJSDocUnknownTag(
        tagName: tsc.Identifier,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocUnknownTag;
    createJSDocUnknownType(): tsc.JSDocUnknownType;
    createJSDocVariadicType(type: tsc.TypeNode): tsc.JSDocVariadicType;
    createJsxAttribute(
        name: tsc.JsxAttributeName,
        initializer: JsxAttributeValue | undefined,
    ): tsc.JsxAttribute;
    createJsxAttributes(
        properties: readonly tsc.JsxAttributeLike[],
    ): JsxAttributes;
    createJsxClosingElement(
        tagName: tsc.JsxTagNameExpression,
    ): tsc.JsxClosingElement;
    createJsxElement(
        openingElement: tsc.JsxOpeningElement,
        children: readonly tsc.JsxChild[],
        closingElement: tsc.JsxClosingElement,
    ): tsc.JsxElement;
    createJsxExpression(
        dotDotDotToken: DotDotDotToken | undefined,
        expression: tsc.Expression | undefined,
    ): tsc.JsxExpression;
    createJsxFragment(
        openingFragment: tsc.JsxOpeningFragment,
        children: readonly tsc.JsxChild[],
        closingFragment: tsc.JsxClosingFragment,
    ): tsc.JsxFragment;
    createJsxJsxClosingFragment(): tsc.JsxClosingFragment;
    createJsxNamespacedName(
        namespace: tsc.Identifier,
        name: tsc.Identifier,
    ): tsc.JsxNamespacedName;
    createJsxOpeningElement(
        tagName: tsc.JsxTagNameExpression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        attributes: JsxAttributes,
    ): tsc.JsxOpeningElement;
    createJsxOpeningFragment(): tsc.JsxOpeningFragment;
    createJsxSelfClosingElement(
        tagName: tsc.JsxTagNameExpression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        attributes: JsxAttributes,
    ): tsc.JsxSelfClosingElement;
    createJsxSpreadAttribute(
        expression: tsc.Expression,
    ): tsc.JsxSpreadAttribute;
    createJsxText(
        text: string,
        containsOnlyTriviaWhiteSpaces?: boolean,
    ): tsc.JsxText;
    createKeywordTypeNode<TKind extends KeywordTypeSyntaxKind>(
        kind: TKind,
    ): KeywordTypeNode<TKind>;
    createLabeledStatement(
        label: string | tsc.Identifier,
        statement: tsc.Statement,
    ): tsc.LabeledStatement;
    createLeftShift(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createLessThan(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createLessThanEquals(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createLiteralTypeNode(
        literal:
            | tsc.LiteralExpression
            | tsc.PrefixUnaryExpression
            | tsc.NullLiteral
            | tsc.BooleanLiteral,
    ): tsc.LiteralTypeNode;
    createLogicalAnd(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createLogicalNot(operand: tsc.Expression): tsc.PrefixUnaryExpression;
    createLogicalOr(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createLoopVariable(reservedInNestedScopes?: boolean): tsc.Identifier;
    createMappedTypeNode(
        readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined,
        typeParameter: tsc.TypeParameterDeclaration,
        nameType: tsc.TypeNode | undefined,
        questionToken: QuestionToken | PlusToken | MinusToken | undefined,
        type: tsc.TypeNode | undefined,
        members: NodeArray<tsc.TypeElement> | undefined,
    ): tsc.MappedTypeNode;
    createMetaProperty(
        keywordToken: ImportKeyword | NewKeyword,
        name: tsc.Identifier,
    ): tsc.MetaProperty;
    createMethodDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        asteriskToken: AsteriskToken | undefined,
        name: string | tsc.PropertyName,
        questionToken: QuestionToken | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
        body: tsc.Block | undefined,
    ): tsc.MethodDeclaration;
    createMethodSignature(
        modifiers: readonly Modifier[] | undefined,
        name: string | tsc.PropertyName,
        questionToken: QuestionToken | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
    ): tsc.MethodSignature;
    createModifier<T extends ModifierSyntaxKind>(kind: T): ModifierToken<T>;
    createModifiersFromModifierFlags(
        flags: ModifierFlags,
    ): Modifier[] | undefined;
    createModuleBlock(statements: readonly tsc.Statement[]): tsc.ModuleBlock;
    createModuleDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        name: tsc.ModuleName,
        body: ModuleBody | undefined,
        flags?: tsc.NodeFlags,
    ): tsc.ModuleDeclaration;
    createModulo(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createMultiply(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createNamedExports(
        elements: readonly tsc.ExportSpecifier[],
    ): tsc.NamedExports;
    createNamedImports(
        elements: readonly tsc.ImportSpecifier[],
    ): tsc.NamedImports;
    createNamedTupleMember(
        dotDotDotToken: DotDotDotToken | undefined,
        name: tsc.Identifier,
        questionToken: QuestionToken | undefined,
        type: tsc.TypeNode,
    ): tsc.NamedTupleMember;
    createNamespaceExport(name: tsc.Identifier): tsc.NamespaceExport;
    createNamespaceExportDeclaration(
        name: string | tsc.Identifier,
    ): NamespaceExportDeclaration;
    createNamespaceImport(name: tsc.Identifier): tsc.NamespaceImport;
    createNewExpression(
        expression: tsc.Expression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        argumentsArray: readonly tsc.Expression[] | undefined,
    ): tsc.NewExpression;
    createNodeArray<T extends tsc.Node>(
        elements?: readonly T[],
        hasTrailingComma?: boolean,
    ): NodeArray<T>;
    createNonNullChain(expression: tsc.Expression): NonNullChain;
    createNonNullExpression(expression: tsc.Expression): tsc.NonNullExpression;
    createNoSubstitutionTemplateLiteral(
        text: string,
        rawText?: string,
    ): tsc.NoSubstitutionTemplateLiteral;
    createNoSubstitutionTemplateLiteral(
        text: string | undefined,
        rawText: string,
    ): tsc.NoSubstitutionTemplateLiteral;
    createNotEmittedStatement(original: tsc.Node): tsc.NotEmittedStatement;
    createNull(): tsc.NullLiteral;
    createNumericLiteral(
        value: string | number,
        numericLiteralFlags?: TokenFlags,
    ): tsc.NumericLiteral;
    createObjectBindingPattern(
        elements: readonly tsc.BindingElement[],
    ): tsc.ObjectBindingPattern;
    createObjectLiteralExpression(
        properties?: readonly tsc.ObjectLiteralElementLike[],
        multiLine?: boolean,
    ): tsc.ObjectLiteralExpression;
    createOmittedExpression(): tsc.OmittedExpression;
    createOptionalTypeNode(type: tsc.TypeNode): OptionalTypeNode;
    createParameterDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        dotDotDotToken: DotDotDotToken | undefined,
        name: string | tsc.BindingName,
        questionToken?: QuestionToken,
        type?: tsc.TypeNode,
        initializer?: tsc.Expression,
    ): tsc.ParameterDeclaration;
    createParenthesizedExpression(
        expression: tsc.Expression,
    ): tsc.ParenthesizedExpression;
    createParenthesizedType(type: tsc.TypeNode): tsc.ParenthesizedTypeNode;
    createPartiallyEmittedExpression(
        expression: tsc.Expression,
        original?: tsc.Node,
    ): tsc.PartiallyEmittedExpression;
    createPostfixDecrement(operand: tsc.Expression): tsc.PostfixUnaryExpression;
    createPostfixIncrement(operand: tsc.Expression): tsc.PostfixUnaryExpression;
    createPostfixUnaryExpression(
        operand: tsc.Expression,
        operator: PostfixUnaryOperator,
    ): tsc.PostfixUnaryExpression;
    createPrefixDecrement(operand: tsc.Expression): tsc.PrefixUnaryExpression;
    createPrefixIncrement(operand: tsc.Expression): tsc.PrefixUnaryExpression;
    createPrefixMinus(operand: tsc.Expression): tsc.PrefixUnaryExpression;
    createPrefixPlus(operand: tsc.Expression): tsc.PrefixUnaryExpression;
    createPrefixUnaryExpression(
        operator: PrefixUnaryOperator,
        operand: tsc.Expression,
    ): tsc.PrefixUnaryExpression;
    createPrivateIdentifier(text: string): tsc.PrivateIdentifier;
    createPropertyAccessChain(
        expression: tsc.Expression,
        questionDotToken: QuestionDotToken | undefined,
        name: string | MemberName,
    ): PropertyAccessChain;
    createPropertyAccessExpression(
        expression: tsc.Expression,
        name: string | MemberName,
    ): tsc.PropertyAccessExpression;
    createPropertyAssignment(
        name: string | tsc.PropertyName,
        initializer: tsc.Expression,
    ): tsc.PropertyAssignment;
    createPropertyDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        name: string | tsc.PropertyName,
        questionOrExclamationToken: ExclamationToken | QuestionToken | undefined,
        type: tsc.TypeNode | undefined,
        initializer: tsc.Expression | undefined,
    ): tsc.PropertyDeclaration;
    createPropertySignature(
        modifiers: readonly Modifier[] | undefined,
        name: string | tsc.PropertyName,
        questionToken: QuestionToken | undefined,
        type: tsc.TypeNode | undefined,
    ): tsc.PropertySignature;
    createQualifiedName(
        left: tsc.EntityName,
        right: string | tsc.Identifier,
    ): tsc.QualifiedName;
    createRegularExpressionLiteral(text: string): tsc.RegularExpressionLiteral;
    createRestTypeNode(type: tsc.TypeNode): tsc.RestTypeNode;
    createReturnStatement(expression?: tsc.Expression): tsc.ReturnStatement;
    createRightShift(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createSatisfiesExpression(
        expression: tsc.Expression,
        type: tsc.TypeNode,
    ): tsc.SatisfiesExpression;
    createSemicolonClassElement(): SemicolonClassElement;
    createSetAccessorDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        name: string | tsc.PropertyName,
        parameters: readonly tsc.ParameterDeclaration[],
        body: tsc.Block | undefined,
    ): tsc.SetAccessorDeclaration;
    createShorthandPropertyAssignment(
        name: string | tsc.Identifier,
        objectAssignmentInitializer?: tsc.Expression,
    ): tsc.ShorthandPropertyAssignment;
    createSourceFile(
        statements: readonly tsc.Statement[],
        endOfFileToken: EndOfFileToken,
        flags: tsc.NodeFlags,
    ): tsc.SourceFile;
    createSpreadAssignment(expression: tsc.Expression): tsc.SpreadAssignment;
    createSpreadElement(expression: tsc.Expression): tsc.SpreadElement;
    createStrictEquality(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createStrictInequality(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createStringLiteral(
        text: string,
        isSingleQuote?: boolean,
    ): tsc.StringLiteral;
    createStringLiteralFromNode(
        sourceNode: tsc.PrivateIdentifier | PropertyNameLiteral,
        isSingleQuote?: boolean,
    ): tsc.StringLiteral;
    createSubtract(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createSuper(): tsc.SuperExpression;
    createSwitchStatement(
        expression: tsc.Expression,
        caseBlock: tsc.CaseBlock,
    ): tsc.SwitchStatement;
    createTaggedTemplateExpression(
        tag: tsc.Expression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        template: tsc.TemplateLiteral,
    ): tsc.TaggedTemplateExpression;
    createTemplateExpression(
        head: tsc.TemplateHead,
        templateSpans: readonly tsc.TemplateSpan[],
    ): tsc.TemplateExpression;
    createTemplateHead(
        text: string,
        rawText?: string,
        templateFlags?: TokenFlags,
    ): tsc.TemplateHead;
    createTemplateHead(
        text: string | undefined,
        rawText: string,
        templateFlags?: TokenFlags,
    ): tsc.TemplateHead;
    createTemplateLiteralType(
        head: tsc.TemplateHead,
        templateSpans: readonly TemplateLiteralTypeSpan[],
    ): tsc.TemplateLiteralTypeNode;
    createTemplateLiteralTypeSpan(
        type: tsc.TypeNode,
        literal: tsc.TemplateMiddle | tsc.TemplateTail,
    ): TemplateLiteralTypeSpan;
    createTemplateMiddle(
        text: string,
        rawText?: string,
        templateFlags?: TokenFlags,
    ): tsc.TemplateMiddle;
    createTemplateMiddle(
        text: string | undefined,
        rawText: string,
        templateFlags?: TokenFlags,
    ): tsc.TemplateMiddle;
    createTemplateSpan(
        expression: tsc.Expression,
        literal: tsc.TemplateMiddle | tsc.TemplateTail,
    ): tsc.TemplateSpan;
    createTemplateTail(
        text: string,
        rawText?: string,
        templateFlags?: TokenFlags,
    ): tsc.TemplateTail;
    createTemplateTail(
        text: string | undefined,
        rawText: string,
        templateFlags?: TokenFlags,
    ): tsc.TemplateTail;
    createTempVariable(
        recordTempVariable: ((node: tsc.Identifier) => void) | undefined,
        reservedInNestedScopes?: boolean,
    ): tsc.Identifier;
    createThis(): tsc.ThisExpression;
    createThisTypeNode(): tsc.ThisTypeNode;
    createThrowStatement(expression: tsc.Expression): tsc.ThrowStatement;
    createToken(token: SuperKeyword): tsc.SuperExpression;
    createToken(token: ThisKeyword): tsc.ThisExpression;
    createToken(token: NullKeyword): tsc.NullLiteral;
    createToken(token: TrueKeyword): tsc.TrueLiteral;
    createToken(token: FalseKeyword): tsc.FalseLiteral;
    createToken(token: EndOfFileToken): EndOfFileToken;
    createToken(token: Unknown): Token<Unknown>;
    createToken<TKind extends PunctuationSyntaxKind>(
        token: TKind,
    ): PunctuationToken<TKind>;
    createToken<TKind extends KeywordTypeSyntaxKind>(
        token: TKind,
    ): KeywordTypeNode<TKind>;
    createToken<TKind extends ModifierSyntaxKind>(
        token: TKind,
    ): ModifierToken<TKind>;
    createToken<TKind extends KeywordSyntaxKind>(
        token: TKind,
    ): KeywordToken<TKind>;
    createTrue(): tsc.TrueLiteral;
    createTryStatement(
        tryBlock: tsc.Block,
        catchClause: tsc.CatchClause | undefined,
        finallyBlock: tsc.Block | undefined,
    ): tsc.TryStatement;
    createTupleTypeNode(
        elements: readonly (tsc.TypeNode | tsc.NamedTupleMember)[],
    ): tsc.TupleTypeNode;
    createTypeAliasDeclaration(
        modifiers: readonly ModifierLike[] | undefined,
        name: string | tsc.Identifier,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        type: tsc.TypeNode,
    ): tsc.TypeAliasDeclaration;
    createTypeAssertion(
        type: tsc.TypeNode,
        expression: tsc.Expression,
    ): tsc.TypeAssertion;
    createTypeLiteralNode(
        members: readonly tsc.TypeElement[] | undefined,
    ): tsc.TypeLiteralNode;
    createTypeOfExpression(expression: tsc.Expression): tsc.TypeOfExpression;
    createTypeOperatorNode(
        operator: KeyOfKeyword | ReadonlyKeyword | UniqueKeyword,
        type: tsc.TypeNode,
    ): TypeOperatorNode;
    createTypeParameterDeclaration(
        modifiers: readonly Modifier[] | undefined,
        name: string | tsc.Identifier,
        constraint?: tsc.TypeNode,
        defaultType?: tsc.TypeNode,
    ): tsc.TypeParameterDeclaration;
    createTypePredicateNode(
        assertsModifier: AssertsKeyword | undefined,
        parameterName: string | tsc.Identifier | tsc.ThisTypeNode,
        type: tsc.TypeNode | undefined,
    ): tsc.TypePredicateNode;
    createTypeQueryNode(
        exprName: tsc.EntityName,
        typeArguments?: readonly tsc.TypeNode[],
    ): tsc.TypeQueryNode;
    createTypeReferenceNode(
        typeName: string | tsc.EntityName,
        typeArguments?: readonly tsc.TypeNode[],
    ): tsc.TypeReferenceNode;
    createUnionTypeNode(types: readonly tsc.TypeNode[]): tsc.UnionTypeNode;
    createUniqueName(
        text: string,
        flags?: GeneratedIdentifierFlags,
    ): tsc.Identifier;
    createUniquePrivateName(text?: string): tsc.PrivateIdentifier;
    createUnsignedRightShift(
        left: tsc.Expression,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    createVariableDeclaration(
        name: string | tsc.BindingName,
        exclamationToken?: ExclamationToken,
        type?: tsc.TypeNode,
        initializer?: tsc.Expression,
    ): tsc.VariableDeclaration;
    createVariableDeclarationList(
        declarations: readonly tsc.VariableDeclaration[],
        flags?: tsc.NodeFlags,
    ): tsc.VariableDeclarationList;
    createVariableStatement(
        modifiers: readonly ModifierLike[] | undefined,
        declarationList:
            | tsc.VariableDeclarationList
            | readonly tsc.VariableDeclaration[],
    ): tsc.VariableStatement;
    createVoidExpression(expression: tsc.Expression): tsc.VoidExpression;
    createVoidZero(): tsc.VoidExpression;
    createWhileStatement(
        expression: tsc.Expression,
        statement: tsc.Statement,
    ): tsc.WhileStatement;
    createWithStatement(
        expression: tsc.Expression,
        statement: tsc.Statement,
    ): tsc.WithStatement;
    createYieldExpression(
        asteriskToken: AsteriskToken,
        expression: tsc.Expression,
    ): tsc.YieldExpression;
    createYieldExpression(
        asteriskToken: undefined,
        expression: tsc.Expression | undefined,
    ): tsc.YieldExpression;
    getGeneratedNameForNode(
        node: tsc.Node | undefined,
        flags?: GeneratedIdentifierFlags,
    ): tsc.Identifier;
    getGeneratedPrivateNameForNode(node: tsc.Node): tsc.PrivateIdentifier;
    replaceDecoratorsAndModifiers<T extends HasModifiers & HasDecorators>(
        node: T,
        modifiers: readonly ModifierLike[] | undefined,
    ): T;
    replaceModifiers<T extends HasModifiers>(
        node: T,
        modifiers: ModifierFlags | readonly Modifier[] | undefined,
    ): T;
    replacePropertyName<
        T extends
            | tsc.MethodDeclaration
            | tsc.MethodSignature
            | tsc.AccessorDeclaration
            | tsc.PropertyAssignment
            | tsc.PropertyDeclaration
            | tsc.PropertySignature,
    >(
        node: T,
        name: T["name"],
    ): T;
    restoreOuterExpressions(
        outerExpression: tsc.Expression | undefined,
        innerExpression: tsc.Expression,
        kinds?: OuterExpressionKinds,
    ): tsc.Expression;
    updateArrayBindingPattern(
        node: tsc.ArrayBindingPattern,
        elements: readonly tsc.ArrayBindingElement[],
    ): tsc.ArrayBindingPattern;
    updateArrayLiteralExpression(
        node: tsc.ArrayLiteralExpression,
        elements: readonly tsc.Expression[],
    ): tsc.ArrayLiteralExpression;
    updateArrayTypeNode(
        node: tsc.ArrayTypeNode,
        elementType: tsc.TypeNode,
    ): tsc.ArrayTypeNode;
    updateArrowFunction(
        node: tsc.ArrowFunction,
        modifiers: readonly Modifier[] | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
        equalsGreaterThanToken: EqualsGreaterThanToken,
        body: ConciseBody,
    ): tsc.ArrowFunction;
    updateAsExpression(
        node: tsc.AsExpression,
        expression: tsc.Expression,
        type: tsc.TypeNode,
    ): tsc.AsExpression;
    updateAssertClause(
        node: AssertClause,
        elements: NodeArray<AssertEntry>,
        multiLine?: boolean,
    ): AssertClause;
    updateAssertEntry(
        node: AssertEntry,
        name: ImportAttributeName,
        value: tsc.Expression,
    ): AssertEntry;
    updateAwaitExpression(
        node: tsc.AwaitExpression,
        expression: tsc.Expression,
    ): tsc.AwaitExpression;
    updateBinaryExpression(
        node: tsc.BinaryExpression,
        left: tsc.Expression,
        operator: BinaryOperatorToken | BinaryOperator,
        right: tsc.Expression,
    ): tsc.BinaryExpression;
    updateBindingElement(
        node: tsc.BindingElement,
        dotDotDotToken: DotDotDotToken | undefined,
        propertyName: tsc.PropertyName | undefined,
        name: tsc.BindingName,
        initializer: tsc.Expression | undefined,
    ): tsc.BindingElement;
    updateBlock(
        node: tsc.Block,
        statements: readonly tsc.Statement[],
    ): tsc.Block;
    updateBreakStatement(
        node: tsc.BreakStatement,
        label: tsc.Identifier | undefined,
    ): tsc.BreakStatement;
    updateBundle(node: Bundle, sourceFiles: readonly tsc.SourceFile[]): Bundle;
    updateCallChain(
        node: CallChain,
        expression: tsc.Expression,
        questionDotToken: QuestionDotToken | undefined,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        argumentsArray: readonly tsc.Expression[],
    ): CallChain;
    updateCallExpression(
        node: tsc.CallExpression,
        expression: tsc.Expression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        argumentsArray: readonly tsc.Expression[],
    ): tsc.CallExpression;
    updateCallSignature(
        node: tsc.CallSignatureDeclaration,
        typeParameters: NodeArray<tsc.TypeParameterDeclaration> | undefined,
        parameters: NodeArray<tsc.ParameterDeclaration>,
        type: tsc.TypeNode | undefined,
    ): tsc.CallSignatureDeclaration;
    updateCaseBlock(
        node: tsc.CaseBlock,
        clauses: readonly tsc.CaseOrDefaultClause[],
    ): tsc.CaseBlock;
    updateCaseClause(
        node: tsc.CaseClause,
        expression: tsc.Expression,
        statements: readonly tsc.Statement[],
    ): tsc.CaseClause;
    updateCatchClause(
        node: tsc.CatchClause,
        variableDeclaration: tsc.VariableDeclaration | undefined,
        block: tsc.Block,
    ): tsc.CatchClause;
    updateClassDeclaration(
        node: tsc.ClassDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        name: tsc.Identifier | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        heritageClauses: readonly tsc.HeritageClause[] | undefined,
        members: readonly tsc.ClassElement[],
    ): tsc.ClassDeclaration;
    updateClassExpression(
        node: tsc.ClassExpression,
        modifiers: readonly ModifierLike[] | undefined,
        name: tsc.Identifier | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        heritageClauses: readonly tsc.HeritageClause[] | undefined,
        members: readonly tsc.ClassElement[],
    ): tsc.ClassExpression;
    updateClassStaticBlockDeclaration(
        node: tsc.ClassStaticBlockDeclaration,
        body: tsc.Block,
    ): tsc.ClassStaticBlockDeclaration;
    updateCommaListExpression(
        node: tsc.CommaListExpression,
        elements: readonly tsc.Expression[],
    ): tsc.CommaListExpression;
    updateComputedPropertyName(
        node: tsc.ComputedPropertyName,
        expression: tsc.Expression,
    ): tsc.ComputedPropertyName;
    updateConditionalExpression(
        node: tsc.ConditionalExpression,
        condition: tsc.Expression,
        questionToken: QuestionToken,
        whenTrue: tsc.Expression,
        colonToken: ColonToken,
        whenFalse: tsc.Expression,
    ): tsc.ConditionalExpression;
    updateConditionalTypeNode(
        node: tsc.ConditionalTypeNode,
        checkType: tsc.TypeNode,
        extendsType: tsc.TypeNode,
        trueType: tsc.TypeNode,
        falseType: tsc.TypeNode,
    ): tsc.ConditionalTypeNode;
    updateConstructorDeclaration(
        node: tsc.ConstructorDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        body: tsc.Block | undefined,
    ): tsc.ConstructorDeclaration;
    updateConstructorTypeNode(
        node: tsc.ConstructorTypeNode,
        modifiers: readonly Modifier[] | undefined,
        typeParameters: NodeArray<tsc.TypeParameterDeclaration> | undefined,
        parameters: NodeArray<tsc.ParameterDeclaration>,
        type: tsc.TypeNode,
    ): tsc.ConstructorTypeNode;
    updateConstructSignature(
        node: tsc.ConstructSignatureDeclaration,
        typeParameters: NodeArray<tsc.TypeParameterDeclaration> | undefined,
        parameters: NodeArray<tsc.ParameterDeclaration>,
        type: tsc.TypeNode | undefined,
    ): tsc.ConstructSignatureDeclaration;
    updateContinueStatement(
        node: tsc.ContinueStatement,
        label: tsc.Identifier | undefined,
    ): tsc.ContinueStatement;
    updateDecorator(
        node: tsc.Decorator,
        expression: tsc.Expression,
    ): tsc.Decorator;
    updateDefaultClause(
        node: tsc.DefaultClause,
        statements: readonly tsc.Statement[],
    ): tsc.DefaultClause;
    updateDeleteExpression(
        node: tsc.DeleteExpression,
        expression: tsc.Expression,
    ): tsc.DeleteExpression;
    updateDoStatement(
        node: tsc.DoStatement,
        statement: tsc.Statement,
        expression: tsc.Expression,
    ): tsc.DoStatement;
    updateElementAccessChain(
        node: ElementAccessChain,
        expression: tsc.Expression,
        questionDotToken: QuestionDotToken | undefined,
        argumentExpression: tsc.Expression,
    ): ElementAccessChain;
    updateElementAccessExpression(
        node: tsc.ElementAccessExpression,
        expression: tsc.Expression,
        argumentExpression: tsc.Expression,
    ): tsc.ElementAccessExpression;
    updateEnumDeclaration(
        node: tsc.EnumDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        name: tsc.Identifier,
        members: readonly tsc.EnumMember[],
    ): tsc.EnumDeclaration;
    updateEnumMember(
        node: tsc.EnumMember,
        name: tsc.PropertyName,
        initializer: tsc.Expression | undefined,
    ): tsc.EnumMember;
    updateExportAssignment(
        node: tsc.ExportAssignment,
        modifiers: readonly ModifierLike[] | undefined,
        expression: tsc.Expression,
    ): tsc.ExportAssignment;
    updateExportDeclaration(
        node: tsc.ExportDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        isTypeOnly: boolean,
        exportClause: NamedExportBindings | undefined,
        moduleSpecifier: tsc.Expression | undefined,
        attributes: tsc.ImportAttributes | undefined,
    ): tsc.ExportDeclaration;
    updateExportSpecifier(
        node: tsc.ExportSpecifier,
        isTypeOnly: boolean,
        propertyName: tsc.Identifier | undefined,
        name: tsc.Identifier,
    ): tsc.ExportSpecifier;
    updateExpressionStatement(
        node: tsc.ExpressionStatement,
        expression: tsc.Expression,
    ): tsc.ExpressionStatement;
    updateExpressionWithTypeArguments(
        node: tsc.ExpressionWithTypeArguments,
        expression: tsc.Expression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
    ): tsc.ExpressionWithTypeArguments;
    updateExternalModuleReference(
        node: tsc.ExternalModuleReference,
        expression: tsc.Expression,
    ): tsc.ExternalModuleReference;
    updateForInStatement(
        node: tsc.ForInStatement,
        initializer: ForInitializer,
        expression: tsc.Expression,
        statement: tsc.Statement,
    ): tsc.ForInStatement;
    updateForOfStatement(
        node: tsc.ForOfStatement,
        awaitModifier: AwaitKeyword | undefined,
        initializer: ForInitializer,
        expression: tsc.Expression,
        statement: tsc.Statement,
    ): tsc.ForOfStatement;
    updateForStatement(
        node: tsc.ForStatement,
        initializer: ForInitializer | undefined,
        condition: tsc.Expression | undefined,
        incrementor: tsc.Expression | undefined,
        statement: tsc.Statement,
    ): tsc.ForStatement;
    updateFunctionDeclaration(
        node: tsc.FunctionDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        asteriskToken: AsteriskToken | undefined,
        name: tsc.Identifier | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
        body: tsc.Block | undefined,
    ): tsc.FunctionDeclaration;
    updateFunctionExpression(
        node: tsc.FunctionExpression,
        modifiers: readonly Modifier[] | undefined,
        asteriskToken: AsteriskToken | undefined,
        name: tsc.Identifier | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
        body: tsc.Block,
    ): tsc.FunctionExpression;
    updateFunctionTypeNode(
        node: tsc.FunctionTypeNode,
        typeParameters: NodeArray<tsc.TypeParameterDeclaration> | undefined,
        parameters: NodeArray<tsc.ParameterDeclaration>,
        type: tsc.TypeNode,
    ): tsc.FunctionTypeNode;
    updateGetAccessorDeclaration(
        node: tsc.GetAccessorDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        name: tsc.PropertyName,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
        body: tsc.Block | undefined,
    ): tsc.GetAccessorDeclaration;
    updateHeritageClause(
        node: tsc.HeritageClause,
        types: readonly tsc.ExpressionWithTypeArguments[],
    ): tsc.HeritageClause;
    updateIfStatement(
        node: tsc.IfStatement,
        expression: tsc.Expression,
        thenStatement: tsc.Statement,
        elseStatement: tsc.Statement | undefined,
    ): tsc.IfStatement;
    updateImportAttribute(
        node: tsc.ImportAttribute,
        name: ImportAttributeName,
        value: tsc.Expression,
    ): tsc.ImportAttribute;
    updateImportAttributes(
        node: tsc.ImportAttributes,
        elements: NodeArray<tsc.ImportAttribute>,
        multiLine?: boolean,
    ): tsc.ImportAttributes;
    updateImportClause(
        node: tsc.ImportClause,
        isTypeOnly: boolean,
        name: tsc.Identifier | undefined,
        namedBindings: NamedImportBindings | undefined,
    ): tsc.ImportClause;
    updateImportDeclaration(
        node: tsc.ImportDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        importClause: tsc.ImportClause | undefined,
        moduleSpecifier: tsc.Expression,
        attributes: tsc.ImportAttributes | undefined,
    ): tsc.ImportDeclaration;
    updateImportEqualsDeclaration(
        node: tsc.ImportEqualsDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        isTypeOnly: boolean,
        name: tsc.Identifier,
        moduleReference: tsc.ModuleReference,
    ): tsc.ImportEqualsDeclaration;
    updateImportSpecifier(
        node: tsc.ImportSpecifier,
        isTypeOnly: boolean,
        propertyName: tsc.Identifier | undefined,
        name: tsc.Identifier,
    ): tsc.ImportSpecifier;
    updateImportTypeAssertionContainer(
        node: ImportTypeAssertionContainer,
        clause: AssertClause,
        multiLine?: boolean,
    ): ImportTypeAssertionContainer;
    updateImportTypeNode(
        node: tsc.ImportTypeNode,
        argument: tsc.TypeNode,
        attributes: tsc.ImportAttributes | undefined,
        qualifier: tsc.EntityName | undefined,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        isTypeOf?: boolean,
    ): tsc.ImportTypeNode;
    updateIndexedAccessTypeNode(
        node: tsc.IndexedAccessTypeNode,
        objectType: tsc.TypeNode,
        indexType: tsc.TypeNode,
    ): tsc.IndexedAccessTypeNode;
    updateIndexSignature(
        node: tsc.IndexSignatureDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode,
    ): tsc.IndexSignatureDeclaration;
    updateInferTypeNode(
        node: tsc.InferTypeNode,
        typeParameter: tsc.TypeParameterDeclaration,
    ): tsc.InferTypeNode;
    updateInterfaceDeclaration(
        node: tsc.InterfaceDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        name: tsc.Identifier,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        heritageClauses: readonly tsc.HeritageClause[] | undefined,
        members: readonly tsc.TypeElement[],
    ): tsc.InterfaceDeclaration;
    updateIntersectionTypeNode(
        node: tsc.IntersectionTypeNode,
        types: NodeArray<tsc.TypeNode>,
    ): tsc.IntersectionTypeNode;
    updateJSDocAugmentsTag(
        node: tsc.JSDocAugmentsTag,
        tagName: tsc.Identifier | undefined,
        className: tsc.ExpressionWithTypeArguments & {
            expression: tsc.Identifier | PropertyAccessEntityNameExpression;
        },
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocAugmentsTag;
    updateJSDocAuthorTag(
        node: tsc.JSDocAuthorTag,
        tagName: tsc.Identifier | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocAuthorTag;
    updateJSDocCallbackTag(
        node: tsc.JSDocCallbackTag,
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocSignature,
        fullName: tsc.Identifier | JSDocNamespaceDeclaration | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocCallbackTag;
    updateJSDocClassTag(
        node: tsc.JSDocClassTag,
        tagName: tsc.Identifier | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocClassTag;
    updateJSDocComment(
        node: tsc.JSDoc,
        comment: string | NodeArray<JSDocComment> | undefined,
        tags: readonly tsc.JSDocTag[] | undefined,
    ): tsc.JSDoc;
    updateJSDocDeprecatedTag(
        node: tsc.JSDocDeprecatedTag,
        tagName: tsc.Identifier | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocDeprecatedTag;
    updateJSDocEnumTag(
        node: tsc.JSDocEnumTag,
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocEnumTag;
    updateJSDocFunctionType(
        node: tsc.JSDocFunctionType,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
    ): tsc.JSDocFunctionType;
    updateJSDocImplementsTag(
        node: tsc.JSDocImplementsTag,
        tagName: tsc.Identifier | undefined,
        className: tsc.ExpressionWithTypeArguments & {
            expression: tsc.Identifier | PropertyAccessEntityNameExpression;
        },
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocImplementsTag;
    updateJSDocImportTag(
        node: JSDocImportTag,
        tagName: tsc.Identifier | undefined,
        importClause: tsc.ImportClause | undefined,
        moduleSpecifier: tsc.Expression,
        attributes: tsc.ImportAttributes | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): JSDocImportTag;
    updateJSDocLink(
        node: tsc.JSDocLink,
        name: tsc.JSDocMemberName | tsc.EntityName | undefined,
        text: string,
    ): tsc.JSDocLink;
    updateJSDocLinkCode(
        node: tsc.JSDocLinkCode,
        name: tsc.JSDocMemberName | tsc.EntityName | undefined,
        text: string,
    ): tsc.JSDocLinkCode;
    updateJSDocLinkPlain(
        node: tsc.JSDocLinkPlain,
        name: tsc.JSDocMemberName | tsc.EntityName | undefined,
        text: string,
    ): tsc.JSDocLinkPlain;
    updateJSDocMemberName(
        node: tsc.JSDocMemberName,
        left: tsc.JSDocMemberName | tsc.EntityName,
        right: tsc.Identifier,
    ): tsc.JSDocMemberName;
    updateJSDocNamepathType(
        node: tsc.JSDocNamepathType,
        type: tsc.TypeNode,
    ): tsc.JSDocNamepathType;
    updateJSDocNameReference(
        node: tsc.JSDocNameReference,
        name: tsc.JSDocMemberName | tsc.EntityName,
    ): tsc.JSDocNameReference;
    updateJSDocNonNullableType(
        node: tsc.JSDocNonNullableType,
        type: tsc.TypeNode,
    ): tsc.JSDocNonNullableType;
    updateJSDocNullableType(
        node: tsc.JSDocNullableType,
        type: tsc.TypeNode,
    ): tsc.JSDocNullableType;
    updateJSDocOptionalType(
        node: tsc.JSDocOptionalType,
        type: tsc.TypeNode,
    ): tsc.JSDocOptionalType;
    updateJSDocOverloadTag(
        node: tsc.JSDocOverloadTag,
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocSignature,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocOverloadTag;
    updateJSDocOverrideTag(
        node: tsc.JSDocOverrideTag,
        tagName: tsc.Identifier | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocOverrideTag;
    updateJSDocParameterTag(
        node: tsc.JSDocParameterTag,
        tagName: tsc.Identifier | undefined,
        name: tsc.EntityName,
        isBracketed: boolean,
        typeExpression: tsc.JSDocTypeExpression | undefined,
        isNameFirst: boolean,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocParameterTag;
    updateJSDocPrivateTag(
        node: tsc.JSDocPrivateTag,
        tagName: tsc.Identifier | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocPrivateTag;
    updateJSDocPropertyTag(
        node: tsc.JSDocPropertyTag,
        tagName: tsc.Identifier | undefined,
        name: tsc.EntityName,
        isBracketed: boolean,
        typeExpression: tsc.JSDocTypeExpression | undefined,
        isNameFirst: boolean,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocPropertyTag;
    updateJSDocProtectedTag(
        node: tsc.JSDocProtectedTag,
        tagName: tsc.Identifier | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocProtectedTag;
    updateJSDocPublicTag(
        node: tsc.JSDocPublicTag,
        tagName: tsc.Identifier | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocPublicTag;
    updateJSDocReadonlyTag(
        node: tsc.JSDocReadonlyTag,
        tagName: tsc.Identifier | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocReadonlyTag;
    updateJSDocReturnTag(
        node: tsc.JSDocReturnTag,
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocReturnTag;
    updateJSDocSatisfiesTag(
        node: tsc.JSDocSatisfiesTag,
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocSatisfiesTag;
    updateJSDocSeeTag(
        node: tsc.JSDocSeeTag,
        tagName: tsc.Identifier | undefined,
        nameExpression: tsc.JSDocNameReference | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocSeeTag;
    updateJSDocSignature(
        node: tsc.JSDocSignature,
        typeParameters: readonly tsc.JSDocTemplateTag[] | undefined,
        parameters: readonly tsc.JSDocParameterTag[],
        type: tsc.JSDocReturnTag | undefined,
    ): tsc.JSDocSignature;
    updateJSDocTemplateTag(
        node: tsc.JSDocTemplateTag,
        tagName: tsc.Identifier | undefined,
        constraint: tsc.JSDocTypeExpression | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[],
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocTemplateTag;
    updateJSDocText(node: tsc.JSDocText, text: string): tsc.JSDocText;
    updateJSDocThisTag(
        node: tsc.JSDocThisTag,
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocThisTag;
    updateJSDocThrowsTag(
        node: tsc.JSDocThrowsTag,
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression | undefined,
        comment?: string | NodeArray<JSDocComment>,
    ): tsc.JSDocThrowsTag;
    updateJSDocTypedefTag(
        node: tsc.JSDocTypedefTag,
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression | tsc.JSDocTypeLiteral | undefined,
        fullName: tsc.Identifier | JSDocNamespaceDeclaration | undefined,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocTypedefTag;
    updateJSDocTypeExpression(
        node: tsc.JSDocTypeExpression,
        type: tsc.TypeNode,
    ): tsc.JSDocTypeExpression;
    updateJSDocTypeLiteral(
        node: tsc.JSDocTypeLiteral,
        jsDocPropertyTags: readonly tsc.JSDocPropertyLikeTag[] | undefined,
        isArrayType: boolean | undefined,
    ): tsc.JSDocTypeLiteral;
    updateJSDocTypeTag(
        node: tsc.JSDocTypeTag,
        tagName: tsc.Identifier | undefined,
        typeExpression: tsc.JSDocTypeExpression,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocTypeTag;
    updateJSDocUnknownTag(
        node: tsc.JSDocUnknownTag,
        tagName: tsc.Identifier,
        comment: string | NodeArray<JSDocComment> | undefined,
    ): tsc.JSDocUnknownTag;
    updateJSDocVariadicType(
        node: tsc.JSDocVariadicType,
        type: tsc.TypeNode,
    ): tsc.JSDocVariadicType;
    updateJsxAttribute(
        node: tsc.JsxAttribute,
        name: tsc.JsxAttributeName,
        initializer: JsxAttributeValue | undefined,
    ): tsc.JsxAttribute;
    updateJsxAttributes(
        node: JsxAttributes,
        properties: readonly tsc.JsxAttributeLike[],
    ): JsxAttributes;
    updateJsxClosingElement(
        node: tsc.JsxClosingElement,
        tagName: tsc.JsxTagNameExpression,
    ): tsc.JsxClosingElement;
    updateJsxElement(
        node: tsc.JsxElement,
        openingElement: tsc.JsxOpeningElement,
        children: readonly tsc.JsxChild[],
        closingElement: tsc.JsxClosingElement,
    ): tsc.JsxElement;
    updateJsxExpression(
        node: tsc.JsxExpression,
        expression: tsc.Expression | undefined,
    ): tsc.JsxExpression;
    updateJsxFragment(
        node: tsc.JsxFragment,
        openingFragment: tsc.JsxOpeningFragment,
        children: readonly tsc.JsxChild[],
        closingFragment: tsc.JsxClosingFragment,
    ): tsc.JsxFragment;
    updateJsxNamespacedName(
        node: tsc.JsxNamespacedName,
        namespace: tsc.Identifier,
        name: tsc.Identifier,
    ): tsc.JsxNamespacedName;
    updateJsxOpeningElement(
        node: tsc.JsxOpeningElement,
        tagName: tsc.JsxTagNameExpression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        attributes: JsxAttributes,
    ): tsc.JsxOpeningElement;
    updateJsxSelfClosingElement(
        node: tsc.JsxSelfClosingElement,
        tagName: tsc.JsxTagNameExpression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        attributes: JsxAttributes,
    ): tsc.JsxSelfClosingElement;
    updateJsxSpreadAttribute(
        node: tsc.JsxSpreadAttribute,
        expression: tsc.Expression,
    ): tsc.JsxSpreadAttribute;
    updateJsxText(
        node: tsc.JsxText,
        text: string,
        containsOnlyTriviaWhiteSpaces?: boolean,
    ): tsc.JsxText;
    updateLabeledStatement(
        node: tsc.LabeledStatement,
        label: tsc.Identifier,
        statement: tsc.Statement,
    ): tsc.LabeledStatement;
    updateLiteralTypeNode(
        node: tsc.LiteralTypeNode,
        literal:
            | tsc.LiteralExpression
            | tsc.PrefixUnaryExpression
            | tsc.NullLiteral
            | tsc.BooleanLiteral,
    ): tsc.LiteralTypeNode;
    updateMappedTypeNode(
        node: tsc.MappedTypeNode,
        readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined,
        typeParameter: tsc.TypeParameterDeclaration,
        nameType: tsc.TypeNode | undefined,
        questionToken: QuestionToken | PlusToken | MinusToken | undefined,
        type: tsc.TypeNode | undefined,
        members: NodeArray<tsc.TypeElement> | undefined,
    ): tsc.MappedTypeNode;
    updateMetaProperty(
        node: tsc.MetaProperty,
        name: tsc.Identifier,
    ): tsc.MetaProperty;
    updateMethodDeclaration(
        node: tsc.MethodDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        asteriskToken: AsteriskToken | undefined,
        name: tsc.PropertyName,
        questionToken: QuestionToken | undefined,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        parameters: readonly tsc.ParameterDeclaration[],
        type: tsc.TypeNode | undefined,
        body: tsc.Block | undefined,
    ): tsc.MethodDeclaration;
    updateMethodSignature(
        node: tsc.MethodSignature,
        modifiers: readonly Modifier[] | undefined,
        name: tsc.PropertyName,
        questionToken: QuestionToken | undefined,
        typeParameters: NodeArray<tsc.TypeParameterDeclaration> | undefined,
        parameters: NodeArray<tsc.ParameterDeclaration>,
        type: tsc.TypeNode | undefined,
    ): tsc.MethodSignature;
    updateModuleBlock(
        node: tsc.ModuleBlock,
        statements: readonly tsc.Statement[],
    ): tsc.ModuleBlock;
    updateModuleDeclaration(
        node: tsc.ModuleDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        name: tsc.ModuleName,
        body: ModuleBody | undefined,
    ): tsc.ModuleDeclaration;
    updateNamedExports(
        node: tsc.NamedExports,
        elements: readonly tsc.ExportSpecifier[],
    ): tsc.NamedExports;
    updateNamedImports(
        node: tsc.NamedImports,
        elements: readonly tsc.ImportSpecifier[],
    ): tsc.NamedImports;
    updateNamedTupleMember(
        node: tsc.NamedTupleMember,
        dotDotDotToken: DotDotDotToken | undefined,
        name: tsc.Identifier,
        questionToken: QuestionToken | undefined,
        type: tsc.TypeNode,
    ): tsc.NamedTupleMember;
    updateNamespaceExport(
        node: tsc.NamespaceExport,
        name: tsc.Identifier,
    ): tsc.NamespaceExport;
    updateNamespaceExportDeclaration(
        node: NamespaceExportDeclaration,
        name: tsc.Identifier,
    ): NamespaceExportDeclaration;
    updateNamespaceImport(
        node: tsc.NamespaceImport,
        name: tsc.Identifier,
    ): tsc.NamespaceImport;
    updateNewExpression(
        node: tsc.NewExpression,
        expression: tsc.Expression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        argumentsArray: readonly tsc.Expression[] | undefined,
    ): tsc.NewExpression;
    updateNonNullChain(
        node: NonNullChain,
        expression: tsc.Expression,
    ): NonNullChain;
    updateNonNullExpression(
        node: tsc.NonNullExpression,
        expression: tsc.Expression,
    ): tsc.NonNullExpression;
    updateObjectBindingPattern(
        node: tsc.ObjectBindingPattern,
        elements: readonly tsc.BindingElement[],
    ): tsc.ObjectBindingPattern;
    updateObjectLiteralExpression(
        node: tsc.ObjectLiteralExpression,
        properties: readonly tsc.ObjectLiteralElementLike[],
    ): tsc.ObjectLiteralExpression;
    updateOptionalTypeNode(
        node: OptionalTypeNode,
        type: tsc.TypeNode,
    ): OptionalTypeNode;
    updateParameterDeclaration(
        node: tsc.ParameterDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        dotDotDotToken: DotDotDotToken | undefined,
        name: string | tsc.BindingName,
        questionToken: QuestionToken | undefined,
        type: tsc.TypeNode | undefined,
        initializer: tsc.Expression | undefined,
    ): tsc.ParameterDeclaration;
    updateParenthesizedExpression(
        node: tsc.ParenthesizedExpression,
        expression: tsc.Expression,
    ): tsc.ParenthesizedExpression;
    updateParenthesizedType(
        node: tsc.ParenthesizedTypeNode,
        type: tsc.TypeNode,
    ): tsc.ParenthesizedTypeNode;
    updatePartiallyEmittedExpression(
        node: tsc.PartiallyEmittedExpression,
        expression: tsc.Expression,
    ): tsc.PartiallyEmittedExpression;
    updatePostfixUnaryExpression(
        node: tsc.PostfixUnaryExpression,
        operand: tsc.Expression,
    ): tsc.PostfixUnaryExpression;
    updatePrefixUnaryExpression(
        node: tsc.PrefixUnaryExpression,
        operand: tsc.Expression,
    ): tsc.PrefixUnaryExpression;
    updatePropertyAccessChain(
        node: PropertyAccessChain,
        expression: tsc.Expression,
        questionDotToken: QuestionDotToken | undefined,
        name: MemberName,
    ): PropertyAccessChain;
    updatePropertyAccessExpression(
        node: tsc.PropertyAccessExpression,
        expression: tsc.Expression,
        name: MemberName,
    ): tsc.PropertyAccessExpression;
    updatePropertyAssignment(
        node: tsc.PropertyAssignment,
        name: tsc.PropertyName,
        initializer: tsc.Expression,
    ): tsc.PropertyAssignment;
    updatePropertyDeclaration(
        node: tsc.PropertyDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        name: string | tsc.PropertyName,
        questionOrExclamationToken: ExclamationToken | QuestionToken | undefined,
        type: tsc.TypeNode | undefined,
        initializer: tsc.Expression | undefined,
    ): tsc.PropertyDeclaration;
    updatePropertySignature(
        node: tsc.PropertySignature,
        modifiers: readonly Modifier[] | undefined,
        name: tsc.PropertyName,
        questionToken: QuestionToken | undefined,
        type: tsc.TypeNode | undefined,
    ): tsc.PropertySignature;
    updateQualifiedName(
        node: tsc.QualifiedName,
        left: tsc.EntityName,
        right: tsc.Identifier,
    ): tsc.QualifiedName;
    updateRestTypeNode(
        node: tsc.RestTypeNode,
        type: tsc.TypeNode,
    ): tsc.RestTypeNode;
    updateReturnStatement(
        node: tsc.ReturnStatement,
        expression: tsc.Expression | undefined,
    ): tsc.ReturnStatement;
    updateSatisfiesExpression(
        node: tsc.SatisfiesExpression,
        expression: tsc.Expression,
        type: tsc.TypeNode,
    ): tsc.SatisfiesExpression;
    updateSetAccessorDeclaration(
        node: tsc.SetAccessorDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        name: tsc.PropertyName,
        parameters: readonly tsc.ParameterDeclaration[],
        body: tsc.Block | undefined,
    ): tsc.SetAccessorDeclaration;
    updateShorthandPropertyAssignment(
        node: tsc.ShorthandPropertyAssignment,
        name: tsc.Identifier,
        objectAssignmentInitializer: tsc.Expression | undefined,
    ): tsc.ShorthandPropertyAssignment;
    updateSourceFile(
        node: tsc.SourceFile,
        statements: readonly tsc.Statement[],
        isDeclarationFile?: boolean,
        referencedFiles?: readonly tsc.FileReference[],
        typeReferences?: readonly tsc.FileReference[],
        hasNoDefaultLib?: boolean,
        libReferences?: readonly tsc.FileReference[],
    ): tsc.SourceFile;
    updateSpreadAssignment(
        node: tsc.SpreadAssignment,
        expression: tsc.Expression,
    ): tsc.SpreadAssignment;
    updateSpreadElement(
        node: tsc.SpreadElement,
        expression: tsc.Expression,
    ): tsc.SpreadElement;
    updateSwitchStatement(
        node: tsc.SwitchStatement,
        expression: tsc.Expression,
        caseBlock: tsc.CaseBlock,
    ): tsc.SwitchStatement;
    updateTaggedTemplateExpression(
        node: tsc.TaggedTemplateExpression,
        tag: tsc.Expression,
        typeArguments: readonly tsc.TypeNode[] | undefined,
        template: tsc.TemplateLiteral,
    ): tsc.TaggedTemplateExpression;
    updateTemplateExpression(
        node: tsc.TemplateExpression,
        head: tsc.TemplateHead,
        templateSpans: readonly tsc.TemplateSpan[],
    ): tsc.TemplateExpression;
    updateTemplateLiteralType(
        node: tsc.TemplateLiteralTypeNode,
        head: tsc.TemplateHead,
        templateSpans: readonly TemplateLiteralTypeSpan[],
    ): tsc.TemplateLiteralTypeNode;
    updateTemplateLiteralTypeSpan(
        node: TemplateLiteralTypeSpan,
        type: tsc.TypeNode,
        literal: tsc.TemplateMiddle | tsc.TemplateTail,
    ): TemplateLiteralTypeSpan;
    updateTemplateSpan(
        node: tsc.TemplateSpan,
        expression: tsc.Expression,
        literal: tsc.TemplateMiddle | tsc.TemplateTail,
    ): tsc.TemplateSpan;
    updateThrowStatement(
        node: tsc.ThrowStatement,
        expression: tsc.Expression,
    ): tsc.ThrowStatement;
    updateTryStatement(
        node: tsc.TryStatement,
        tryBlock: tsc.Block,
        catchClause: tsc.CatchClause | undefined,
        finallyBlock: tsc.Block | undefined,
    ): tsc.TryStatement;
    updateTupleTypeNode(
        node: tsc.TupleTypeNode,
        elements: readonly (tsc.TypeNode | tsc.NamedTupleMember)[],
    ): tsc.TupleTypeNode;
    updateTypeAliasDeclaration(
        node: tsc.TypeAliasDeclaration,
        modifiers: readonly ModifierLike[] | undefined,
        name: tsc.Identifier,
        typeParameters: readonly tsc.TypeParameterDeclaration[] | undefined,
        type: tsc.TypeNode,
    ): tsc.TypeAliasDeclaration;
    updateTypeAssertion(
        node: tsc.TypeAssertion,
        type: tsc.TypeNode,
        expression: tsc.Expression,
    ): tsc.TypeAssertion;
    updateTypeLiteralNode(
        node: tsc.TypeLiteralNode,
        members: NodeArray<tsc.TypeElement>,
    ): tsc.TypeLiteralNode;
    updateTypeOfExpression(
        node: tsc.TypeOfExpression,
        expression: tsc.Expression,
    ): tsc.TypeOfExpression;
    updateTypeOperatorNode(
        node: TypeOperatorNode,
        type: tsc.TypeNode,
    ): TypeOperatorNode;
    updateTypeParameterDeclaration(
        node: tsc.TypeParameterDeclaration,
        modifiers: readonly Modifier[] | undefined,
        name: tsc.Identifier,
        constraint: tsc.TypeNode | undefined,
        defaultType: tsc.TypeNode | undefined,
    ): tsc.TypeParameterDeclaration;
    updateTypePredicateNode(
        node: tsc.TypePredicateNode,
        assertsModifier: AssertsKeyword | undefined,
        parameterName: tsc.Identifier | tsc.ThisTypeNode,
        type: tsc.TypeNode | undefined,
    ): tsc.TypePredicateNode;
    updateTypeQueryNode(
        node: tsc.TypeQueryNode,
        exprName: tsc.EntityName,
        typeArguments?: readonly tsc.TypeNode[],
    ): tsc.TypeQueryNode;
    updateTypeReferenceNode(
        node: tsc.TypeReferenceNode,
        typeName: tsc.EntityName,
        typeArguments: NodeArray<tsc.TypeNode> | undefined,
    ): tsc.TypeReferenceNode;
    updateUnionTypeNode(
        node: tsc.UnionTypeNode,
        types: NodeArray<tsc.TypeNode>,
    ): tsc.UnionTypeNode;
    updateVariableDeclaration(
        node: tsc.VariableDeclaration,
        name: tsc.BindingName,
        exclamationToken: ExclamationToken | undefined,
        type: tsc.TypeNode | undefined,
        initializer: tsc.Expression | undefined,
    ): tsc.VariableDeclaration;
    updateVariableDeclarationList(
        node: tsc.VariableDeclarationList,
        declarations: readonly tsc.VariableDeclaration[],
    ): tsc.VariableDeclarationList;
    updateVariableStatement(
        node: tsc.VariableStatement,
        modifiers: readonly ModifierLike[] | undefined,
        declarationList: tsc.VariableDeclarationList,
    ): tsc.VariableStatement;
    updateVoidExpression(
        node: tsc.VoidExpression,
        expression: tsc.Expression,
    ): tsc.VoidExpression;
    updateWhileStatement(
        node: tsc.WhileStatement,
        expression: tsc.Expression,
        statement: tsc.Statement,
    ): tsc.WhileStatement;
    updateWithStatement(
        node: tsc.WithStatement,
        expression: tsc.Expression,
        statement: tsc.Statement,
    ): tsc.WithStatement;
    updateYieldExpression(
        node: tsc.YieldExpression,
        asteriskToken: AsteriskToken | undefined,
        expression: tsc.Expression | undefined,
    ): tsc.YieldExpression;
}