Interface NodeFactory

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