kotlin-typescript/typescript/NodeFactory

NodeFactory

sealed external interface NodeFactory(source)

Functions

abstract fun createAdd(left: Expression, right: Expression): BinaryExpression

abstract fun createArrayBindingPattern(elements: <Error class: unknown class><ArrayBindingElement>): ArrayBindingPattern

createArrayLiteralExpression

abstract fun createArrayLiteralExpression( elements: <Error class: unknown class><Expression> = definedExternally, multiLine: Boolean = definedExternally): ArrayLiteralExpression

createArrayTypeNode

abstract fun createArrayTypeNode(elementType: TypeNode): ArrayTypeNode

createArrowFunction

abstract fun createArrowFunction( modifiers: <Error class: unknown class><Modifier>?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, equalsGreaterThanToken: EqualsGreaterThanToken?, body: ConciseBody): ArrowFunction

createAsExpression

abstract fun createAsExpression(expression: Expression, type: TypeNode): AsExpression

createAssertClause

abstract fun createAssertClause(elements: NodeArray<AssertEntry>, multiLine: Boolean = definedExternally): AssertClause

createAssertEntry

abstract fun createAssertEntry(name: AssertionKey, value: Expression): AssertEntry

createAssignment

abstract fun createAssignment(left: ArrayLiteralExpression, right: Expression): DestructuringAssignment

abstract fun createAssignment(left: Expression, right: Expression): AssignmentExpression<EqualsToken>

abstract fun createAssignment(left: ObjectLiteralExpression, right: Expression): DestructuringAssignment

createAwaitExpression

abstract fun createAwaitExpression(expression: Expression): AwaitExpression

createBigIntLiteral

abstract fun createBigIntLiteral(value: String): BigIntLiteral

abstract fun createBigIntLiteral(value: PseudoBigInt): BigIntLiteral

createBinaryExpression

abstract fun createBinaryExpression(left: Expression, operator: BinaryOperator, right: Expression): BinaryExpression

abstract fun createBinaryExpression(left: Expression, operator: BinaryOperatorToken, right: Expression): BinaryExpression

createBindingElement

abstract fun createBindingElement( dotDotDotToken: DotDotDotToken?, propertyName: String?, name: String, initializer: Expression = definedExternally): BindingElement

abstract fun createBindingElement( dotDotDotToken: DotDotDotToken?, propertyName: String?, name: BindingName, initializer: Expression = definedExternally): BindingElement

abstract fun createBindingElement( dotDotDotToken: DotDotDotToken?, propertyName: PropertyName?, name: String, initializer: Expression = definedExternally): BindingElement

abstract fun createBindingElement( dotDotDotToken: DotDotDotToken?, propertyName: PropertyName?, name: BindingName, initializer: Expression = definedExternally): BindingElement

createBitwiseAnd

abstract fun createBitwiseAnd(left: Expression, right: Expression): BinaryExpression

createBitwiseNot

abstract fun createBitwiseNot(operand: Expression): PrefixUnaryExpression

createBitwiseOr

abstract fun createBitwiseOr(left: Expression, right: Expression): BinaryExpression

createBitwiseXor

abstract fun createBitwiseXor(left: Expression, right: Expression): BinaryExpression

createBlock

abstract fun createBlock(statements: <Error class: unknown class><Statement>, multiLine: Boolean = definedExternally): Block

createBreakStatement

abstract fun createBreakStatement(): BreakStatement

abstract fun createBreakStatement(label: String = definedExternally): BreakStatement

abstract fun createBreakStatement(label: Identifier = definedExternally): BreakStatement

createBundle

abstract fun createBundle(sourceFiles: <Error class: unknown class><SourceFile>): Bundle

createCallChain

abstract fun createCallChain( expression: Expression, questionDotToken: QuestionDotToken?, typeArguments: <Error class: unknown class><TypeNode>?, argumentsArray: <Error class: unknown class><Expression>?): CallChain

createCallExpression

abstract fun createCallExpression( expression: Expression, typeArguments: <Error class: unknown class><TypeNode>?, argumentsArray: <Error class: unknown class><Expression>?): CallExpression

createCallSignature

abstract fun createCallSignature( typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?): CallSignatureDeclaration

createCaseBlock

abstract fun createCaseBlock(clauses: <Error class: unknown class><CaseOrDefaultClause>): CaseBlock

createCaseClause

abstract fun createCaseClause(expression: Expression, statements: <Error class: unknown class><Statement>): CaseClause

createCatchClause

abstract fun createCatchClause(variableDeclaration: String?, block: Block): CatchClause

abstract fun createCatchClause(variableDeclaration: BindingName?, block: Block): CatchClause

abstract fun createCatchClause(variableDeclaration: VariableDeclaration?, block: Block): CatchClause

createClassDeclaration

abstract fun createClassDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: String?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, heritageClauses: <Error class: unknown class><HeritageClause>?, members: <Error class: unknown class><ClassElement>): ClassDeclaration

abstract fun createClassDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: Identifier?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, heritageClauses: <Error class: unknown class><HeritageClause>?, members: <Error class: unknown class><ClassElement>): ClassDeclaration

createClassExpression

abstract fun createClassExpression( modifiers: <Error class: unknown class><ModifierLike>?, name: String?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, heritageClauses: <Error class: unknown class><HeritageClause>?, members: <Error class: unknown class><ClassElement>): ClassExpression

abstract fun createClassExpression( modifiers: <Error class: unknown class><ModifierLike>?, name: Identifier?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, heritageClauses: <Error class: unknown class><HeritageClause>?, members: <Error class: unknown class><ClassElement>): ClassExpression

createClassStaticBlockDeclaration

abstract fun createClassStaticBlockDeclaration(body: Block): ClassStaticBlockDeclaration

createComma

abstract fun createComma(left: Expression, right: Expression): BinaryExpression

createCommaListExpression

abstract fun createCommaListExpression(elements: <Error class: unknown class><Expression>): CommaListExpression

createComputedPropertyName

abstract fun createComputedPropertyName(expression: Expression): ComputedPropertyName

createConditionalExpression

abstract fun createConditionalExpression( condition: Expression, questionToken: QuestionToken?, whenTrue: Expression, colonToken: ColonToken?, whenFalse: Expression): ConditionalExpression

createConditionalTypeNode

abstract fun createConditionalTypeNode( checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode): ConditionalTypeNode

createConstructorDeclaration

abstract fun createConstructorDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, parameters: <Error class: unknown class><ParameterDeclaration>, body: Block?): ConstructorDeclaration

createConstructorTypeNode

abstract fun createConstructorTypeNode( modifiers: <Error class: unknown class><Modifier>?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode): ConstructorTypeNode

createConstructSignature

abstract fun createConstructSignature( typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?): ConstructSignatureDeclaration

createContinueStatement

abstract fun createContinueStatement(): ContinueStatement

abstract fun createContinueStatement(label: String = definedExternally): ContinueStatement

abstract fun createContinueStatement(label: Identifier = definedExternally): ContinueStatement

createDebuggerStatement

abstract fun createDebuggerStatement(): DebuggerStatement

createDecorator

abstract fun createDecorator(expression: Expression): Decorator

createDefaultClause

abstract fun createDefaultClause(statements: <Error class: unknown class><Statement>): DefaultClause

createDeleteExpression

abstract fun createDeleteExpression(expression: Expression): DeleteExpression

createDivide

abstract fun createDivide(left: Expression, right: Expression): BinaryExpression

createDoStatement

abstract fun createDoStatement(statement: Statement, expression: Expression): DoStatement

createElementAccessChain

abstract fun createElementAccessChain(expression: Expression, questionDotToken: QuestionDotToken?, index: Double): ElementAccessChain

abstract fun createElementAccessChain(expression: Expression, questionDotToken: QuestionDotToken?, index: Expression): ElementAccessChain

createElementAccessExpression

abstract fun createElementAccessExpression(expression: Expression, index: Double): ElementAccessExpression

abstract fun createElementAccessExpression(expression: Expression, index: Expression): ElementAccessExpression

createEmptyStatement

abstract fun createEmptyStatement(): EmptyStatement

createEnumDeclaration

abstract fun createEnumDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: String, members: <Error class: unknown class><EnumMember>): EnumDeclaration

abstract fun createEnumDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: Identifier, members: <Error class: unknown class><EnumMember>): EnumDeclaration

createEnumMember

abstract fun createEnumMember(name: String, initializer: Expression = definedExternally): EnumMember

abstract fun createEnumMember(name: PropertyName, initializer: Expression = definedExternally): EnumMember

createEquality

abstract fun createEquality(left: Expression, right: Expression): BinaryExpression

createExponent

abstract fun createExponent(left: Expression, right: Expression): BinaryExpression

createExportAssignment

abstract fun createExportAssignment( modifiers: <Error class: unknown class><ModifierLike>?, isExportEquals: Boolean?, expression: Expression): ExportAssignment

createExportDeclaration

abstract fun createExportDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, isTypeOnly: Boolean, exportClause: NamedExportBindings?, moduleSpecifier: Expression = definedExternally, attributes: ImportAttributes = definedExternally): ExportDeclaration

createExportDefault

abstract fun createExportDefault(expression: Expression): ExportAssignment

createExportSpecifier

abstract fun createExportSpecifier(isTypeOnly: Boolean, propertyName: String?, name: String): ExportSpecifier

abstract fun createExportSpecifier(isTypeOnly: Boolean, propertyName: String?, name: ModuleExportName): ExportSpecifier

abstract fun createExportSpecifier(isTypeOnly: Boolean, propertyName: ModuleExportName?, name: String): ExportSpecifier

abstract fun createExportSpecifier(isTypeOnly: Boolean, propertyName: ModuleExportName?, name: ModuleExportName): ExportSpecifier

createExpressionStatement

abstract fun createExpressionStatement(expression: Expression): ExpressionStatement

createExpressionWithTypeArguments

abstract fun createExpressionWithTypeArguments( expression: Expression, typeArguments: <Error class: unknown class><TypeNode>?): ExpressionWithTypeArguments

createExternalModuleExport

abstract fun createExternalModuleExport(exportName: Identifier): ExportDeclaration

createExternalModuleReference

abstract fun createExternalModuleReference(expression: Expression): ExternalModuleReference

createFalse

abstract fun createFalse(): FalseLiteral

createForInStatement

abstract fun createForInStatement(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement

createForOfStatement

abstract fun createForOfStatement( awaitModifier: AwaitKeyword?, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement

createForStatement

abstract fun createForStatement(initializer: ForInitializer?, condition: Expression?, incrementor: Expression?, statement: Statement): ForStatement

createFunctionDeclaration

abstract fun createFunctionDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, asteriskToken: AsteriskToken?, name: String?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, body: Block?): FunctionDeclaration

abstract fun createFunctionDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, asteriskToken: AsteriskToken?, name: Identifier?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, body: Block?): FunctionDeclaration

createFunctionExpression

abstract fun createFunctionExpression( modifiers: <Error class: unknown class><Modifier>?, asteriskToken: AsteriskToken?, name: String?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>?, type: TypeNode?, body: Block): FunctionExpression

abstract fun createFunctionExpression( modifiers: <Error class: unknown class><Modifier>?, asteriskToken: AsteriskToken?, name: Identifier?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>?, type: TypeNode?, body: Block): FunctionExpression

createFunctionTypeNode

abstract fun createFunctionTypeNode( typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode): FunctionTypeNode

createGetAccessorDeclaration

abstract fun createGetAccessorDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: String, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, body: Block?): GetAccessorDeclaration

abstract fun createGetAccessorDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: PropertyName, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, body: Block?): GetAccessorDeclaration

createGreaterThan

abstract fun createGreaterThan(left: Expression, right: Expression): BinaryExpression

createGreaterThanEquals

abstract fun createGreaterThanEquals(left: Expression, right: Expression): BinaryExpression

createHeritageClause

abstract fun createHeritageClause( token: NodeFactoryCreateHeritageClauseToken, types: <Error class: unknown class><ExpressionWithTypeArguments>): HeritageClause

createIdentifier

abstract fun createIdentifier(text: String): Identifier

createIfStatement

abstract fun createIfStatement(expression: Expression, thenStatement: Statement, elseStatement: Statement = definedExternally): IfStatement

createImmediatelyInvokedArrowFunction

abstract fun createImmediatelyInvokedArrowFunction(statements: <Error class: unknown class><Statement>): ImmediatelyInvokedArrowFunction

abstract fun createImmediatelyInvokedArrowFunction( statements: <Error class: unknown class><Statement>, param: ParameterDeclaration, paramValue: Expression): ImmediatelyInvokedArrowFunction

createImmediatelyInvokedFunctionExpression

abstract fun createImmediatelyInvokedFunctionExpression(statements: <Error class: unknown class><Statement>): CallExpression

abstract fun createImmediatelyInvokedFunctionExpression( statements: <Error class: unknown class><Statement>, param: ParameterDeclaration, paramValue: Expression): CallExpression

createImportAttribute

abstract fun createImportAttribute(name: ImportAttributeName, value: Expression): ImportAttribute

createImportAttributes

abstract fun createImportAttributes(elements: NodeArray<ImportAttribute>, multiLine: Boolean = definedExternally): ImportAttributes

createImportClause

abstract fun createImportClause(isTypeOnly: Boolean, name: Identifier?, namedBindings: NamedImportBindings?): ImportClause

createImportDeclaration

abstract fun createImportDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, importClause: ImportClause?, moduleSpecifier: Expression, attributes: ImportAttributes = definedExternally): ImportDeclaration

createImportEqualsDeclaration

abstract fun createImportEqualsDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, isTypeOnly: Boolean, name: String, moduleReference: ModuleReference): ImportEqualsDeclaration

abstract fun createImportEqualsDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, isTypeOnly: Boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration

createImportSpecifier

abstract fun createImportSpecifier(isTypeOnly: Boolean, propertyName: ModuleExportName?, name: Identifier): ImportSpecifier

createImportTypeAssertionContainer

abstract fun createImportTypeAssertionContainer(clause: AssertClause, multiLine: Boolean = definedExternally): ImportTypeAssertionContainer

createImportTypeNode

abstract fun createImportTypeNode( argument: TypeNode, attributes: ImportAttributes = definedExternally, qualifier: EntityName = definedExternally, typeArguments: <Error class: unknown class><TypeNode> = definedExternally, isTypeOf: Boolean = definedExternally): ImportTypeNode

createIndexedAccessTypeNode

abstract fun createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode

createIndexSignature

abstract fun createIndexSignature( modifiers: <Error class: unknown class><ModifierLike>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode): IndexSignatureDeclaration

createInequality

abstract fun createInequality(left: Expression, right: Expression): BinaryExpression

createInferTypeNode

abstract fun createInferTypeNode(typeParameter: TypeParameterDeclaration): InferTypeNode

createInterfaceDeclaration

abstract fun createInterfaceDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: String, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, heritageClauses: <Error class: unknown class><HeritageClause>?, members: <Error class: unknown class><TypeElement>): InterfaceDeclaration

abstract fun createInterfaceDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: Identifier, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, heritageClauses: <Error class: unknown class><HeritageClause>?, members: <Error class: unknown class><TypeElement>): InterfaceDeclaration

createIntersectionTypeNode

abstract fun createIntersectionTypeNode(types: <Error class: unknown class><TypeNode>): IntersectionTypeNode

createJSDocAllType

abstract fun createJSDocAllType(): JSDocAllType

createJSDocAugmentsTag

abstract fun createJSDocAugmentsTag(tagName: Identifier?, className: JSDocAugmentsTagClass): JSDocAugmentsTag

abstract fun createJSDocAugmentsTag( tagName: Identifier?, className: JSDocAugmentsTagClass, comment: String = definedExternally): JSDocAugmentsTag

abstract fun createJSDocAugmentsTag( tagName: Identifier?, className: JSDocAugmentsTagClass, comment: NodeArray<JSDocComment> = definedExternally): JSDocAugmentsTag

createJSDocAuthorTag

abstract fun createJSDocAuthorTag(tagName: Identifier?): JSDocAuthorTag

abstract fun createJSDocAuthorTag(tagName: Identifier?, comment: String = definedExternally): JSDocAuthorTag

abstract fun createJSDocAuthorTag(tagName: Identifier?, comment: NodeArray<JSDocComment> = definedExternally): JSDocAuthorTag

createJSDocCallbackTag

abstract fun createJSDocCallbackTag(tagName: Identifier?, typeExpression: JSDocSignature): JSDocCallbackTag

abstract fun createJSDocCallbackTag( tagName: Identifier?, typeExpression: JSDocSignature, fullName: Identifier = definedExternally, comment: String = definedExternally): JSDocCallbackTag

abstract fun createJSDocCallbackTag( tagName: Identifier?, typeExpression: JSDocSignature, fullName: Identifier = definedExternally, comment: NodeArray<JSDocComment> = definedExternally): JSDocCallbackTag

abstract fun createJSDocCallbackTag( tagName: Identifier?, typeExpression: JSDocSignature, fullName: JSDocNamespaceDeclaration = definedExternally, comment: String = definedExternally): JSDocCallbackTag

abstract fun createJSDocCallbackTag( tagName: Identifier?, typeExpression: JSDocSignature, fullName: JSDocNamespaceDeclaration = definedExternally, comment: NodeArray<JSDocComment> = definedExternally): JSDocCallbackTag

createJSDocClassTag

abstract fun createJSDocClassTag(tagName: Identifier?): JSDocClassTag

abstract fun createJSDocClassTag(tagName: Identifier?, comment: String = definedExternally): JSDocClassTag

abstract fun createJSDocClassTag(tagName: Identifier?, comment: NodeArray<JSDocComment> = definedExternally): JSDocClassTag

createJSDocComment

abstract fun createJSDocComment(): JSDoc

abstract fun createJSDocComment( comment: String? = definedExternally, tags: <Error class: unknown class><JSDocTag>? = definedExternally): JSDoc

abstract fun createJSDocComment( comment: NodeArray<JSDocComment>? = definedExternally, tags: <Error class: unknown class><JSDocTag>? = definedExternally): JSDoc

createJSDocDeprecatedTag

abstract fun createJSDocDeprecatedTag(tagName: Identifier?): JSDocDeprecatedTag

abstract fun createJSDocDeprecatedTag(tagName: Identifier?, comment: String = definedExternally): JSDocDeprecatedTag

abstract fun createJSDocDeprecatedTag(tagName: Identifier?, comment: NodeArray<JSDocComment> = definedExternally): JSDocDeprecatedTag

createJSDocEnumTag

abstract fun createJSDocEnumTag(tagName: Identifier?, typeExpression: JSDocTypeExpression): JSDocEnumTag

abstract fun createJSDocEnumTag(tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: String = definedExternally): JSDocEnumTag

abstract fun createJSDocEnumTag( tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: NodeArray<JSDocComment> = definedExternally): JSDocEnumTag

createJSDocFunctionType

abstract fun createJSDocFunctionType(parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?): JSDocFunctionType

createJSDocImplementsTag

abstract fun createJSDocImplementsTag(tagName: Identifier?, className: JSDocImplementsTagClass): JSDocImplementsTag

abstract fun createJSDocImplementsTag( tagName: Identifier?, className: JSDocImplementsTagClass, comment: String = definedExternally): JSDocImplementsTag

abstract fun createJSDocImplementsTag( tagName: Identifier?, className: JSDocImplementsTagClass, comment: NodeArray<JSDocComment> = definedExternally): JSDocImplementsTag

createJSDocImportTag

abstract fun createJSDocImportTag( tagName: Identifier?, importClause: ImportClause?, moduleSpecifier: Expression, attributes: ImportAttributes = definedExternally, comment: String = definedExternally): JSDocImportTag

createJSDocLink

abstract fun createJSDocLink(name: EntityName?, text: String): JSDocLink

abstract fun createJSDocLink(name: JSDocMemberName?, text: String): JSDocLink

createJSDocLinkCode

abstract fun createJSDocLinkCode(name: EntityName?, text: String): JSDocLinkCode

abstract fun createJSDocLinkCode(name: JSDocMemberName?, text: String): JSDocLinkCode

createJSDocLinkPlain

abstract fun createJSDocLinkPlain(name: EntityName?, text: String): JSDocLinkPlain

abstract fun createJSDocLinkPlain(name: JSDocMemberName?, text: String): JSDocLinkPlain

createJSDocMemberName

abstract fun createJSDocMemberName(left: EntityName, right: Identifier): JSDocMemberName

abstract fun createJSDocMemberName(left: JSDocMemberName, right: Identifier): JSDocMemberName

createJSDocNamepathType

abstract fun createJSDocNamepathType(type: TypeNode): JSDocNamepathType

createJSDocNameReference

abstract fun createJSDocNameReference(name: EntityName): JSDocNameReference

abstract fun createJSDocNameReference(name: JSDocMemberName): JSDocNameReference

createJSDocNonNullableType

abstract fun createJSDocNonNullableType(type: TypeNode, postfix: Boolean = definedExternally): JSDocNonNullableType

createJSDocNullableType

abstract fun createJSDocNullableType(type: TypeNode, postfix: Boolean = definedExternally): JSDocNullableType

createJSDocOptionalType

abstract fun createJSDocOptionalType(type: TypeNode): JSDocOptionalType

createJSDocOverloadTag

abstract fun createJSDocOverloadTag(tagName: Identifier?, typeExpression: JSDocSignature): JSDocOverloadTag

abstract fun createJSDocOverloadTag(tagName: Identifier?, typeExpression: JSDocSignature, comment: String = definedExternally): JSDocOverloadTag

abstract fun createJSDocOverloadTag( tagName: Identifier?, typeExpression: JSDocSignature, comment: NodeArray<JSDocComment> = definedExternally): JSDocOverloadTag

createJSDocOverrideTag

abstract fun createJSDocOverrideTag(tagName: Identifier?): JSDocOverrideTag

abstract fun createJSDocOverrideTag(tagName: Identifier?, comment: String = definedExternally): JSDocOverrideTag

abstract fun createJSDocOverrideTag(tagName: Identifier?, comment: NodeArray<JSDocComment> = definedExternally): JSDocOverrideTag

createJSDocParameterTag

abstract fun createJSDocParameterTag( tagName: Identifier?, name: EntityName, isBracketed: Boolean, typeExpression: JSDocTypeExpression = definedExternally, isNameFirst: Boolean = definedExternally, comment: String = definedExternally): JSDocParameterTag

createJSDocPrivateTag

abstract fun createJSDocPrivateTag(tagName: Identifier?): JSDocPrivateTag

abstract fun createJSDocPrivateTag(tagName: Identifier?, comment: String = definedExternally): JSDocPrivateTag

abstract fun createJSDocPrivateTag(tagName: Identifier?, comment: NodeArray<JSDocComment> = definedExternally): JSDocPrivateTag

createJSDocPropertyTag

abstract fun createJSDocPropertyTag( tagName: Identifier?, name: EntityName, isBracketed: Boolean, typeExpression: JSDocTypeExpression = definedExternally, isNameFirst: Boolean = definedExternally, comment: String = definedExternally): JSDocPropertyTag

createJSDocProtectedTag

abstract fun createJSDocProtectedTag(tagName: Identifier?): JSDocProtectedTag

abstract fun createJSDocProtectedTag(tagName: Identifier?, comment: String = definedExternally): JSDocProtectedTag

abstract fun createJSDocProtectedTag(tagName: Identifier?, comment: NodeArray<JSDocComment> = definedExternally): JSDocProtectedTag

createJSDocPublicTag

abstract fun createJSDocPublicTag(tagName: Identifier?): JSDocPublicTag

abstract fun createJSDocPublicTag(tagName: Identifier?, comment: String = definedExternally): JSDocPublicTag

abstract fun createJSDocPublicTag(tagName: Identifier?, comment: NodeArray<JSDocComment> = definedExternally): JSDocPublicTag

createJSDocReadonlyTag

abstract fun createJSDocReadonlyTag(tagName: Identifier?): JSDocReadonlyTag

abstract fun createJSDocReadonlyTag(tagName: Identifier?, comment: String = definedExternally): JSDocReadonlyTag

abstract fun createJSDocReadonlyTag(tagName: Identifier?, comment: NodeArray<JSDocComment> = definedExternally): JSDocReadonlyTag

createJSDocReturnTag

abstract fun createJSDocReturnTag( tagName: Identifier?, typeExpression: JSDocTypeExpression = definedExternally, comment: String = definedExternally): JSDocReturnTag

abstract fun createJSDocReturnTag( tagName: Identifier?, typeExpression: JSDocTypeExpression = definedExternally, comment: NodeArray<JSDocComment> = definedExternally): JSDocReturnTag

createJSDocSatisfiesTag

abstract fun createJSDocSatisfiesTag(tagName: Identifier?, typeExpression: JSDocTypeExpression): JSDocSatisfiesTag

abstract fun createJSDocSatisfiesTag( tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: String = definedExternally): JSDocSatisfiesTag

abstract fun createJSDocSatisfiesTag( tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: NodeArray<JSDocComment> = definedExternally): JSDocSatisfiesTag

createJSDocSeeTag

abstract fun createJSDocSeeTag(tagName: Identifier?, nameExpression: JSDocNameReference?): JSDocSeeTag

abstract fun createJSDocSeeTag(tagName: Identifier?, nameExpression: JSDocNameReference?, comment: String = definedExternally): JSDocSeeTag

abstract fun createJSDocSeeTag( tagName: Identifier?, nameExpression: JSDocNameReference?, comment: NodeArray<JSDocComment> = definedExternally): JSDocSeeTag

createJSDocSignature

abstract fun createJSDocSignature( typeParameters: <Error class: unknown class><JSDocTemplateTag>?, parameters: <Error class: unknown class><JSDocParameterTag>, type: JSDocReturnTag = definedExternally): JSDocSignature

createJSDocTemplateTag

abstract fun createJSDocTemplateTag( tagName: Identifier?, constraint: JSDocTypeExpression?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>): JSDocTemplateTag

abstract fun createJSDocTemplateTag( tagName: Identifier?, constraint: JSDocTypeExpression?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>, comment: String = definedExternally): JSDocTemplateTag

createJSDocText

abstract fun createJSDocText(text: String): JSDocText

createJSDocThisTag

abstract fun createJSDocThisTag(tagName: Identifier?, typeExpression: JSDocTypeExpression): JSDocThisTag

abstract fun createJSDocThisTag(tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: String = definedExternally): JSDocThisTag

abstract fun createJSDocThisTag( tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: NodeArray<JSDocComment> = definedExternally): JSDocThisTag

createJSDocThrowsTag

abstract fun createJSDocThrowsTag(tagName: Identifier, typeExpression: JSDocTypeExpression?): JSDocThrowsTag

abstract fun createJSDocThrowsTag( tagName: Identifier, typeExpression: JSDocTypeExpression?, comment: String = definedExternally): JSDocThrowsTag

abstract fun createJSDocThrowsTag( tagName: Identifier, typeExpression: JSDocTypeExpression?, comment: NodeArray<JSDocComment> = definedExternally): JSDocThrowsTag

createJSDocTypedefTag

abstract fun createJSDocTypedefTag(tagName: Identifier?): JSDocTypedefTag

abstract fun createJSDocTypedefTag( tagName: Identifier?, typeExpression: JSDocTypeExpression = definedExternally, fullName: Identifier = definedExternally, comment: String = definedExternally): JSDocTypedefTag

abstract fun createJSDocTypedefTag( tagName: Identifier?, typeExpression: JSDocTypeExpression = definedExternally, fullName: JSDocNamespaceDeclaration = definedExternally, comment: String = definedExternally): JSDocTypedefTag

abstract fun createJSDocTypedefTag( tagName: Identifier?, typeExpression: JSDocTypeLiteral = definedExternally, fullName: Identifier = definedExternally, comment: String = definedExternally): JSDocTypedefTag

abstract fun createJSDocTypedefTag( tagName: Identifier?, typeExpression: JSDocTypeLiteral = definedExternally, fullName: Identifier = definedExternally, comment: NodeArray<JSDocComment> = definedExternally): JSDocTypedefTag

abstract fun createJSDocTypedefTag( tagName: Identifier?, typeExpression: JSDocTypeLiteral = definedExternally, fullName: JSDocNamespaceDeclaration = definedExternally, comment: String = definedExternally): JSDocTypedefTag

createJSDocTypeExpression

abstract fun createJSDocTypeExpression(type: TypeNode): JSDocTypeExpression

createJSDocTypeLiteral

abstract fun createJSDocTypeLiteral( jsDocPropertyTags: <Error class: unknown class><JSDocPropertyLikeTag> = definedExternally, isArrayType: Boolean = definedExternally): JSDocTypeLiteral

createJSDocTypeTag

abstract fun createJSDocTypeTag(tagName: Identifier?, typeExpression: JSDocTypeExpression): JSDocTypeTag

abstract fun createJSDocTypeTag(tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: String = definedExternally): JSDocTypeTag

abstract fun createJSDocTypeTag( tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: NodeArray<JSDocComment> = definedExternally): JSDocTypeTag

createJSDocUnknownTag

abstract fun createJSDocUnknownTag(tagName: Identifier): JSDocUnknownTag

abstract fun createJSDocUnknownTag(tagName: Identifier, comment: String = definedExternally): JSDocUnknownTag

abstract fun createJSDocUnknownTag(tagName: Identifier, comment: NodeArray<JSDocComment> = definedExternally): JSDocUnknownTag

createJSDocUnknownType

abstract fun createJSDocUnknownType(): JSDocUnknownType

createJSDocVariadicType

abstract fun createJSDocVariadicType(type: TypeNode): JSDocVariadicType

createJsxAttribute

abstract fun createJsxAttribute(name: JsxAttributeName, initializer: JsxAttributeValue?): JsxAttribute

createJsxAttributes

abstract fun createJsxAttributes(properties: <Error class: unknown class><JsxAttributeLike>): JsxAttributes

createJsxClosingElement

abstract fun createJsxClosingElement(tagName: JsxTagNameExpression): JsxClosingElement

createJsxElement

abstract fun createJsxElement( openingElement: JsxOpeningElement, children: <Error class: unknown class><JsxChild>, closingElement: JsxClosingElement): JsxElement

createJsxExpression

abstract fun createJsxExpression(dotDotDotToken: DotDotDotToken?, expression: Expression?): JsxExpression

createJsxFragment

abstract fun createJsxFragment( openingFragment: JsxOpeningFragment, children: <Error class: unknown class><JsxChild>, closingFragment: JsxClosingFragment): JsxFragment

createJsxJsxClosingFragment

abstract fun createJsxJsxClosingFragment(): JsxClosingFragment

createJsxNamespacedName

abstract fun createJsxNamespacedName(namespace: Identifier, name: Identifier): JsxNamespacedName

createJsxOpeningElement

abstract fun createJsxOpeningElement( tagName: JsxTagNameExpression, typeArguments: <Error class: unknown class><TypeNode>?, attributes: JsxAttributes): JsxOpeningElement

createJsxOpeningFragment

abstract fun createJsxOpeningFragment(): JsxOpeningFragment

createJsxSelfClosingElement

abstract fun createJsxSelfClosingElement( tagName: JsxTagNameExpression, typeArguments: <Error class: unknown class><TypeNode>?, attributes: JsxAttributes): JsxSelfClosingElement

createJsxSpreadAttribute

abstract fun createJsxSpreadAttribute(expression: Expression): JsxSpreadAttribute

createJsxText

abstract fun createJsxText(text: String, containsOnlyTriviaWhiteSpaces: Boolean = definedExternally): JsxText

createKeywordTypeNode

abstract fun <TKind : KeywordTypeSyntaxKind> createKeywordTypeNode(kind: TKind): KeywordTypeNode<TKind>

createLabeledStatement

abstract fun createLabeledStatement(label: String, statement: Statement): LabeledStatement

abstract fun createLabeledStatement(label: Identifier, statement: Statement): LabeledStatement

createLeftShift

abstract fun createLeftShift(left: Expression, right: Expression): BinaryExpression

createLessThan

abstract fun createLessThan(left: Expression, right: Expression): BinaryExpression

createLessThanEquals

abstract fun createLessThanEquals(left: Expression, right: Expression): BinaryExpression

createLiteralTypeNode

abstract fun createLiteralTypeNode(literal: NodeFactoryCreateLiteralTypeNodeLiteral): LiteralTypeNode

createLogicalAnd

abstract fun createLogicalAnd(left: Expression, right: Expression): BinaryExpression

createLogicalNot

abstract fun createLogicalNot(operand: Expression): PrefixUnaryExpression

createLogicalOr

abstract fun createLogicalOr(left: Expression, right: Expression): BinaryExpression

createLoopVariable

abstract fun createLoopVariable(reservedInNestedScopes: Boolean = definedExternally): Identifier

Create a unique temporary variable for use in a loop.

createMappedTypeNode

abstract fun createMappedTypeNode( readonlyToken: ReadonlyKeyword?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: MinusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun createMappedTypeNode( readonlyToken: ReadonlyKeyword?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: PlusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun createMappedTypeNode( readonlyToken: ReadonlyKeyword?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: QuestionToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun createMappedTypeNode( readonlyToken: MinusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: MinusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun createMappedTypeNode( readonlyToken: MinusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: PlusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun createMappedTypeNode( readonlyToken: MinusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: QuestionToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun createMappedTypeNode( readonlyToken: PlusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: MinusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun createMappedTypeNode( readonlyToken: PlusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: PlusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun createMappedTypeNode( readonlyToken: PlusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: QuestionToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

createMetaProperty

abstract fun createMetaProperty(keywordToken: NodeFactoryCreateMetaPropertyKeywordToken, name: Identifier): MetaProperty

createMethodDeclaration

abstract fun createMethodDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, asteriskToken: AsteriskToken?, name: String, questionToken: QuestionToken?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, body: Block?): MethodDeclaration

abstract fun createMethodDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, asteriskToken: AsteriskToken?, name: PropertyName, questionToken: QuestionToken?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, body: Block?): MethodDeclaration

createMethodSignature

abstract fun createMethodSignature( modifiers: <Error class: unknown class><Modifier>?, name: String, questionToken: QuestionToken?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?): MethodSignature

abstract fun createMethodSignature( modifiers: <Error class: unknown class><Modifier>?, name: PropertyName, questionToken: QuestionToken?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?): MethodSignature

createModifier

abstract fun <T : ModifierSyntaxKind> createModifier(kind: T): ModifierToken<T>

createModifiersFromModifierFlags

abstract fun createModifiersFromModifierFlags(flags: ModifierFlags): <Error class: unknown class><Modifier>?

createModuleBlock

abstract fun createModuleBlock(statements: <Error class: unknown class><Statement>): ModuleBlock

createModuleDeclaration

abstract fun createModuleDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: ModuleName, body: ModuleBody?, flags: NodeFlags = definedExternally): ModuleDeclaration

createModulo

abstract fun createModulo(left: Expression, right: Expression): BinaryExpression

createMultiply

abstract fun createMultiply(left: Expression, right: Expression): BinaryExpression

createNamedExports

abstract fun createNamedExports(elements: <Error class: unknown class><ExportSpecifier>): NamedExports

createNamedImports

abstract fun createNamedImports(elements: <Error class: unknown class><ImportSpecifier>): NamedImports

createNamedTupleMember

abstract fun createNamedTupleMember( dotDotDotToken: DotDotDotToken?, name: Identifier, questionToken: QuestionToken?, type: TypeNode): NamedTupleMember

createNamespaceExport

abstract fun createNamespaceExport(name: ModuleExportName): NamespaceExport

createNamespaceExportDeclaration

abstract fun createNamespaceExportDeclaration(name: String): NamespaceExportDeclaration

abstract fun createNamespaceExportDeclaration(name: Identifier): NamespaceExportDeclaration

createNamespaceImport

abstract fun createNamespaceImport(name: Identifier): NamespaceImport

createNewExpression

abstract fun createNewExpression( expression: Expression, typeArguments: <Error class: unknown class><TypeNode>?, argumentsArray: <Error class: unknown class><Expression>?): NewExpression

createNodeArray

abstract fun <T : Node> createNodeArray( elements: <Error class: unknown class><T> = definedExternally, hasTrailingComma: Boolean = definedExternally): NodeArray<T>

createNonNullChain

abstract fun createNonNullChain(expression: Expression): NonNullChain

createNonNullExpression

abstract fun createNonNullExpression(expression: Expression): NonNullExpression

createNoSubstitutionTemplateLiteral

abstract fun createNoSubstitutionTemplateLiteral(text: String, rawText: String = definedExternally): NoSubstitutionTemplateLiteral

abstract fun createNoSubstitutionTemplateLiteral(text: String?, rawText: String): NoSubstitutionTemplateLiteral

createNotEmittedStatement

abstract fun createNotEmittedStatement(original: Node): NotEmittedStatement

createNotEmittedTypeElement

abstract fun createNotEmittedTypeElement(): NotEmittedTypeElement

createNull

abstract fun createNull(): NullLiteral

createNumericLiteral

abstract fun createNumericLiteral(value: Double, numericLiteralFlags: TokenFlags = definedExternally): NumericLiteral

abstract fun createNumericLiteral(value: String, numericLiteralFlags: TokenFlags = definedExternally): NumericLiteral

createObjectBindingPattern

abstract fun createObjectBindingPattern(elements: <Error class: unknown class><BindingElement>): ObjectBindingPattern

createObjectLiteralExpression

abstract fun createObjectLiteralExpression( properties: <Error class: unknown class><ObjectLiteralElementLike> = definedExternally, multiLine: Boolean = definedExternally): ObjectLiteralExpression

createOmittedExpression

abstract fun createOmittedExpression(): OmittedExpression

createOptionalTypeNode

abstract fun createOptionalTypeNode(type: TypeNode): OptionalTypeNode

createParameterDeclaration

abstract fun createParameterDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, dotDotDotToken: DotDotDotToken?, name: String, questionToken: QuestionToken = definedExternally, type: TypeNode = definedExternally, initializer: Expression = definedExternally): ParameterDeclaration

abstract fun createParameterDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, dotDotDotToken: DotDotDotToken?, name: BindingName, questionToken: QuestionToken = definedExternally, type: TypeNode = definedExternally, initializer: Expression = definedExternally): ParameterDeclaration

createParenthesizedExpression

abstract fun createParenthesizedExpression(expression: Expression): ParenthesizedExpression

createParenthesizedType

abstract fun createParenthesizedType(type: TypeNode): ParenthesizedTypeNode

createPartiallyEmittedExpression

abstract fun createPartiallyEmittedExpression(expression: Expression, original: Node = definedExternally): PartiallyEmittedExpression

createPostfixDecrement

abstract fun createPostfixDecrement(operand: Expression): PostfixUnaryExpression

createPostfixIncrement

abstract fun createPostfixIncrement(operand: Expression): PostfixUnaryExpression

createPostfixUnaryExpression

abstract fun createPostfixUnaryExpression(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression

createPrefixDecrement

abstract fun createPrefixDecrement(operand: Expression): PrefixUnaryExpression

createPrefixIncrement

abstract fun createPrefixIncrement(operand: Expression): PrefixUnaryExpression

createPrefixMinus

abstract fun createPrefixMinus(operand: Expression): PrefixUnaryExpression

createPrefixPlus

abstract fun createPrefixPlus(operand: Expression): PrefixUnaryExpression

createPrefixUnaryExpression

abstract fun createPrefixUnaryExpression(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression

createPrivateIdentifier

abstract fun createPrivateIdentifier(text: String): PrivateIdentifier

createPropertyAccessChain

abstract fun createPropertyAccessChain(expression: Expression, questionDotToken: QuestionDotToken?, name: String): PropertyAccessChain

abstract fun createPropertyAccessChain(expression: Expression, questionDotToken: QuestionDotToken?, name: MemberName): PropertyAccessChain

createPropertyAccessExpression

abstract fun createPropertyAccessExpression(expression: Expression, name: String): PropertyAccessExpression

abstract fun createPropertyAccessExpression(expression: Expression, name: MemberName): PropertyAccessExpression

createPropertyAssignment

abstract fun createPropertyAssignment(name: String, initializer: Expression): PropertyAssignment

abstract fun createPropertyAssignment(name: PropertyName, initializer: Expression): PropertyAssignment

createPropertyDeclaration

abstract fun createPropertyDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: String, questionOrExclamationToken: ExclamationToken?, type: TypeNode?, initializer: Expression?): PropertyDeclaration

abstract fun createPropertyDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: String, questionOrExclamationToken: QuestionToken?, type: TypeNode?, initializer: Expression?): PropertyDeclaration

abstract fun createPropertyDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: PropertyName, questionOrExclamationToken: ExclamationToken?, type: TypeNode?, initializer: Expression?): PropertyDeclaration

abstract fun createPropertyDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: PropertyName, questionOrExclamationToken: QuestionToken?, type: TypeNode?, initializer: Expression?): PropertyDeclaration

createPropertySignature

abstract fun createPropertySignature( modifiers: <Error class: unknown class><Modifier>?, name: String, questionToken: QuestionToken?, type: TypeNode?): PropertySignature

abstract fun createPropertySignature( modifiers: <Error class: unknown class><Modifier>?, name: PropertyName, questionToken: QuestionToken?, type: TypeNode?): PropertySignature

createQualifiedName

abstract fun createQualifiedName(left: EntityName, right: String): QualifiedName

abstract fun createQualifiedName(left: EntityName, right: Identifier): QualifiedName

createRegularExpressionLiteral

abstract fun createRegularExpressionLiteral(text: String): RegularExpressionLiteral

createRestTypeNode

abstract fun createRestTypeNode(type: TypeNode): RestTypeNode

createReturnStatement

abstract fun createReturnStatement(expression: Expression = definedExternally): ReturnStatement

createRightShift

abstract fun createRightShift(left: Expression, right: Expression): BinaryExpression

createSatisfiesExpression

abstract fun createSatisfiesExpression(expression: Expression, type: TypeNode): SatisfiesExpression

createSemicolonClassElement

abstract fun createSemicolonClassElement(): SemicolonClassElement

createSetAccessorDeclaration

abstract fun createSetAccessorDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: String, parameters: <Error class: unknown class><ParameterDeclaration>, body: Block?): SetAccessorDeclaration

abstract fun createSetAccessorDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: PropertyName, parameters: <Error class: unknown class><ParameterDeclaration>, body: Block?): SetAccessorDeclaration

createShorthandPropertyAssignment

abstract fun createShorthandPropertyAssignment( name: String, objectAssignmentInitializer: Expression = definedExternally): ShorthandPropertyAssignment

abstract fun createShorthandPropertyAssignment( name: Identifier, objectAssignmentInitializer: Expression = definedExternally): ShorthandPropertyAssignment

createSourceFile

abstract fun createSourceFile(statements: <Error class: unknown class><Statement>, endOfFileToken: EndOfFileToken, flags: NodeFlags): SourceFile

createSpreadAssignment

abstract fun createSpreadAssignment(expression: Expression): SpreadAssignment

createSpreadElement

abstract fun createSpreadElement(expression: Expression): SpreadElement

createStrictEquality

abstract fun createStrictEquality(left: Expression, right: Expression): BinaryExpression

createStrictInequality

abstract fun createStrictInequality(left: Expression, right: Expression): BinaryExpression

createStringLiteral

abstract fun createStringLiteral(text: String, isSingleQuote: Boolean = definedExternally): StringLiteral

createStringLiteralFromNode

abstract fun createStringLiteralFromNode(sourceNode: PrivateIdentifier, isSingleQuote: Boolean = definedExternally): StringLiteral

abstract fun createStringLiteralFromNode(sourceNode: PropertyNameLiteral, isSingleQuote: Boolean = definedExternally): StringLiteral

createSubtract

abstract fun createSubtract(left: Expression, right: Expression): BinaryExpression

createSuper

abstract fun createSuper(): SuperExpression

createSwitchStatement

abstract fun createSwitchStatement(expression: Expression, caseBlock: CaseBlock): SwitchStatement

createTaggedTemplateExpression

abstract fun createTaggedTemplateExpression( tag: Expression, typeArguments: <Error class: unknown class><TypeNode>?, template: TemplateLiteral): TaggedTemplateExpression

createTemplateExpression

abstract fun createTemplateExpression(head: TemplateHead, templateSpans: <Error class: unknown class><TemplateSpan>): TemplateExpression

createTemplateHead

abstract fun createTemplateHead(text: String, rawText: String = definedExternally, templateFlags: TokenFlags = definedExternally): TemplateHead

abstract fun createTemplateHead(text: String?, rawText: String, templateFlags: TokenFlags = definedExternally): TemplateHead

createTemplateLiteralType

abstract fun createTemplateLiteralType( head: TemplateHead, templateSpans: <Error class: unknown class><TemplateLiteralTypeSpan>): TemplateLiteralTypeNode

createTemplateLiteralTypeSpan

abstract fun createTemplateLiteralTypeSpan(type: TypeNode, literal: TemplateMiddle): TemplateLiteralTypeSpan

abstract fun createTemplateLiteralTypeSpan(type: TypeNode, literal: TemplateTail): TemplateLiteralTypeSpan

createTemplateMiddle

abstract fun createTemplateMiddle(text: String, rawText: String = definedExternally, templateFlags: TokenFlags = definedExternally): TemplateMiddle

abstract fun createTemplateMiddle(text: String?, rawText: String, templateFlags: TokenFlags = definedExternally): TemplateMiddle

createTemplateSpan

abstract fun createTemplateSpan(expression: Expression, literal: TemplateMiddle): TemplateSpan

abstract fun createTemplateSpan(expression: Expression, literal: TemplateTail): TemplateSpan

createTemplateTail

abstract fun createTemplateTail(text: String, rawText: String = definedExternally, templateFlags: TokenFlags = definedExternally): TemplateTail

abstract fun createTemplateTail(text: String?, rawText: String, templateFlags: TokenFlags = definedExternally): TemplateTail

createTempVariable

abstract fun createTempVariable(recordTempVariable: (node: Identifier) -> Unit?, reservedInNestedScopes: Boolean = definedExternally): Identifier

Create a unique temporary variable.

createThis

abstract fun createThis(): ThisExpression

createThisTypeNode

abstract fun createThisTypeNode(): ThisTypeNode

createThrowStatement

abstract fun createThrowStatement(expression: Expression): ThrowStatement

createToken

abstract fun <TKind : KeywordSyntaxKind> createToken(token: TKind): KeywordToken<TKind>

abstract fun <TKind : KeywordTypeSyntaxKind> createToken(token: TKind): KeywordTypeNode<TKind>

abstract fun <TKind : ModifierSyntaxKind> createToken(token: TKind): ModifierToken<TKind>

abstract fun <TKind : PunctuationSyntaxKind> createToken(token: TKind): PunctuationToken<TKind>

abstract fun createToken(token: SyntaxKind.EndOfFileToken): EndOfFileToken

abstract fun createToken(token: SyntaxKind.FalseKeyword): FalseLiteral

abstract fun createToken(token: SyntaxKind.NullKeyword): NullLiteral

abstract fun createToken(token: SyntaxKind.SuperKeyword): SuperExpression

abstract fun createToken(token: SyntaxKind.ThisKeyword): ThisExpression

abstract fun createToken(token: SyntaxKind.TrueKeyword): TrueLiteral

abstract fun createToken(token: SyntaxKind.Unknown): Token<SyntaxKind.Unknown>

createTrue

abstract fun createTrue(): TrueLiteral

createTryStatement

abstract fun createTryStatement(tryBlock: Block, catchClause: CatchClause?, finallyBlock: Block?): TryStatement

createTupleTypeNode

abstract fun createTupleTypeNode(elements: <Error class: unknown class><NodeFactoryCreateTupleTypeNodeElementsItem>): TupleTypeNode

createTypeAliasDeclaration

abstract fun createTypeAliasDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: String, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, type: TypeNode): TypeAliasDeclaration

abstract fun createTypeAliasDeclaration( modifiers: <Error class: unknown class><ModifierLike>?, name: Identifier, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, type: TypeNode): TypeAliasDeclaration

createTypeAssertion

abstract fun createTypeAssertion(type: TypeNode, expression: Expression): TypeAssertion

createTypeLiteralNode

abstract fun createTypeLiteralNode(members: <Error class: unknown class><TypeElement>?): TypeLiteralNode

createTypeOfExpression

abstract fun createTypeOfExpression(expression: Expression): TypeOfExpression

createTypeOperatorNode

abstract fun createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword, type: TypeNode): TypeOperatorNode

abstract fun createTypeOperatorNode(operator: SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode

abstract fun createTypeOperatorNode(operator: SyntaxKind.UniqueKeyword, type: TypeNode): TypeOperatorNode

createTypeParameterDeclaration

abstract fun createTypeParameterDeclaration( modifiers: <Error class: unknown class><Modifier>?, name: String, constraint: TypeNode = definedExternally, defaultType: TypeNode = definedExternally): TypeParameterDeclaration

abstract fun createTypeParameterDeclaration( modifiers: <Error class: unknown class><Modifier>?, name: Identifier, constraint: TypeNode = definedExternally, defaultType: TypeNode = definedExternally): TypeParameterDeclaration

createTypePredicateNode

abstract fun createTypePredicateNode(assertsModifier: AssertsKeyword?, parameterName: String, type: TypeNode?): TypePredicateNode

abstract fun createTypePredicateNode(assertsModifier: AssertsKeyword?, parameterName: Identifier, type: TypeNode?): TypePredicateNode

abstract fun createTypePredicateNode(assertsModifier: AssertsKeyword?, parameterName: ThisTypeNode, type: TypeNode?): TypePredicateNode

createTypeQueryNode

abstract fun createTypeQueryNode( exprName: EntityName, typeArguments: <Error class: unknown class><TypeNode> = definedExternally): TypeQueryNode

createTypeReferenceNode

abstract fun createTypeReferenceNode( typeName: String, typeArguments: <Error class: unknown class><TypeNode> = definedExternally): TypeReferenceNode

abstract fun createTypeReferenceNode( typeName: EntityName, typeArguments: <Error class: unknown class><TypeNode> = definedExternally): TypeReferenceNode

createUnionTypeNode

abstract fun createUnionTypeNode(types: <Error class: unknown class><TypeNode>): UnionTypeNode

createUniqueName

abstract fun createUniqueName(text: String, flags: GeneratedIdentifierFlags = definedExternally): Identifier

Create a unique name based on the supplied text.

createUniquePrivateName

abstract fun createUniquePrivateName(text: String = definedExternally): PrivateIdentifier

createUnsignedRightShift

abstract fun createUnsignedRightShift(left: Expression, right: Expression): BinaryExpression

createVariableDeclaration

abstract fun createVariableDeclaration( name: String, exclamationToken: ExclamationToken = definedExternally, type: TypeNode = definedExternally, initializer: Expression = definedExternally): VariableDeclaration

abstract fun createVariableDeclaration( name: BindingName, exclamationToken: ExclamationToken = definedExternally, type: TypeNode = definedExternally, initializer: Expression = definedExternally): VariableDeclaration

createVariableDeclarationList

abstract fun createVariableDeclarationList( declarations: <Error class: unknown class><VariableDeclaration>, flags: NodeFlags = definedExternally): VariableDeclarationList

createVariableStatement

abstract fun createVariableStatement( modifiers: <Error class: unknown class><ModifierLike>?, declarationList: <Error class: unknown class><VariableDeclaration>): VariableStatement

abstract fun createVariableStatement( modifiers: <Error class: unknown class><ModifierLike>?, declarationList: VariableDeclarationList): VariableStatement

createVoidExpression

abstract fun createVoidExpression(expression: Expression): VoidExpression

createVoidZero

abstract fun createVoidZero(): VoidExpression

createWhileStatement

abstract fun createWhileStatement(expression: Expression, statement: Statement): WhileStatement

createWithStatement

abstract fun createWithStatement(expression: Expression, statement: Statement): WithStatement

createYieldExpression

abstract fun createYieldExpression(asteriskToken: Nothing?, expression: Expression?): YieldExpression

abstract fun createYieldExpression(asteriskToken: AsteriskToken, expression: Expression): YieldExpression

getGeneratedNameForNode

abstract fun getGeneratedNameForNode(node: Node?, flags: GeneratedIdentifierFlags = definedExternally): Identifier

Create a unique name generated for a node.

getGeneratedPrivateNameForNode

abstract fun getGeneratedPrivateNameForNode(node: Node): PrivateIdentifier

replaceDecoratorsAndModifiers

abstract fun <T : NodeFactoryReplaceDecoratorsAndModifiersTConstraint> replaceDecoratorsAndModifiers( node: T, modifiers: <Error class: unknown class><ModifierLike>?): T

Updates a node that may contain decorators or modifiers, replacing only the decorators and modifiers of the node.

replaceModifiers

abstract fun <T : HasModifiers> replaceModifiers(node: T, modifiers: <Error class: unknown class><Modifier>?): T

abstract fun <T : HasModifiers> replaceModifiers(node: T, modifiers: ModifierFlags?): T

Updates a node that may contain modifiers, replacing only the modifiers of the node.

replacePropertyName

abstract fun <T : NodeFactoryReplacePropertyNameTConstraint> replacePropertyName(node: T, name: Any?): T

Updates a node that contains a property name, replacing only the name of the node.

restoreOuterExpressions

abstract fun restoreOuterExpressions( outerExpression: Expression?, innerExpression: Expression, kinds: OuterExpressionKinds = definedExternally): Expression

updateArrayBindingPattern

abstract fun updateArrayBindingPattern( node: ArrayBindingPattern, elements: <Error class: unknown class><ArrayBindingElement>): ArrayBindingPattern

updateArrayLiteralExpression

abstract fun updateArrayLiteralExpression( node: ArrayLiteralExpression, elements: <Error class: unknown class><Expression>): ArrayLiteralExpression

updateArrayTypeNode

abstract fun updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode

updateArrowFunction

abstract fun updateArrowFunction( node: ArrowFunction, modifiers: <Error class: unknown class><Modifier>?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction

updateAsExpression

abstract fun updateAsExpression(node: AsExpression, expression: Expression, type: TypeNode): AsExpression

updateAssertClause

abstract fun updateAssertClause(node: AssertClause, elements: NodeArray<AssertEntry>, multiLine: Boolean = definedExternally): AssertClause

updateAssertEntry

abstract fun updateAssertEntry(node: AssertEntry, name: AssertionKey, value: Expression): AssertEntry

updateAwaitExpression

abstract fun updateAwaitExpression(node: AwaitExpression, expression: Expression): AwaitExpression

updateBinaryExpression

abstract fun updateBinaryExpression(node: BinaryExpression, left: Expression, operator: BinaryOperator, right: Expression): BinaryExpression

abstract fun updateBinaryExpression(node: BinaryExpression, left: Expression, operator: BinaryOperatorToken, right: Expression): BinaryExpression

updateBindingElement

abstract fun updateBindingElement( node: BindingElement, dotDotDotToken: DotDotDotToken?, propertyName: PropertyName?, name: BindingName, initializer: Expression?): BindingElement

updateBlock

abstract fun updateBlock(node: Block, statements: <Error class: unknown class><Statement>): Block

updateBreakStatement

abstract fun updateBreakStatement(node: BreakStatement, label: Identifier?): BreakStatement

updateBundle

abstract fun updateBundle(node: Bundle, sourceFiles: <Error class: unknown class><SourceFile>): Bundle

updateCallChain

abstract fun updateCallChain( node: CallChain, expression: Expression, questionDotToken: QuestionDotToken?, typeArguments: <Error class: unknown class><TypeNode>?, argumentsArray: <Error class: unknown class><Expression>): CallChain

updateCallExpression

abstract fun updateCallExpression( node: CallExpression, expression: Expression, typeArguments: <Error class: unknown class><TypeNode>?, argumentsArray: <Error class: unknown class><Expression>): CallExpression

updateCallSignature

abstract fun updateCallSignature( node: CallSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration>?, parameters: NodeArray<ParameterDeclaration>, type: TypeNode?): CallSignatureDeclaration

updateCaseBlock

abstract fun updateCaseBlock(node: CaseBlock, clauses: <Error class: unknown class><CaseOrDefaultClause>): CaseBlock

updateCaseClause

abstract fun updateCaseClause(node: CaseClause, expression: Expression, statements: <Error class: unknown class><Statement>): CaseClause

updateCatchClause

abstract fun updateCatchClause(node: CatchClause, variableDeclaration: VariableDeclaration?, block: Block): CatchClause

updateClassDeclaration

abstract fun updateClassDeclaration( node: ClassDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: Identifier?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, heritageClauses: <Error class: unknown class><HeritageClause>?, members: <Error class: unknown class><ClassElement>): ClassDeclaration

updateClassExpression

abstract fun updateClassExpression( node: ClassExpression, modifiers: <Error class: unknown class><ModifierLike>?, name: Identifier?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, heritageClauses: <Error class: unknown class><HeritageClause>?, members: <Error class: unknown class><ClassElement>): ClassExpression

updateClassStaticBlockDeclaration

abstract fun updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, body: Block): ClassStaticBlockDeclaration

updateCommaListExpression

abstract fun updateCommaListExpression(node: CommaListExpression, elements: <Error class: unknown class><Expression>): CommaListExpression

updateComputedPropertyName

abstract fun updateComputedPropertyName(node: ComputedPropertyName, expression: Expression): ComputedPropertyName

updateConditionalExpression

abstract fun updateConditionalExpression( node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression

updateConditionalTypeNode

abstract fun updateConditionalTypeNode( node: ConditionalTypeNode, checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode): ConditionalTypeNode

updateConstructorDeclaration

abstract fun updateConstructorDeclaration( node: ConstructorDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, parameters: <Error class: unknown class><ParameterDeclaration>, body: Block?): ConstructorDeclaration

updateConstructorTypeNode

abstract fun updateConstructorTypeNode( node: ConstructorTypeNode, modifiers: <Error class: unknown class><Modifier>?, typeParameters: NodeArray<TypeParameterDeclaration>?, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): ConstructorTypeNode

updateConstructSignature

abstract fun updateConstructSignature( node: ConstructSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration>?, parameters: NodeArray<ParameterDeclaration>, type: TypeNode?): ConstructSignatureDeclaration

updateContinueStatement

abstract fun updateContinueStatement(node: ContinueStatement, label: Identifier?): ContinueStatement

updateDecorator

abstract fun updateDecorator(node: Decorator, expression: Expression): Decorator

updateDefaultClause

abstract fun updateDefaultClause(node: DefaultClause, statements: <Error class: unknown class><Statement>): DefaultClause

updateDeleteExpression

abstract fun updateDeleteExpression(node: DeleteExpression, expression: Expression): DeleteExpression

updateDoStatement

abstract fun updateDoStatement(node: DoStatement, statement: Statement, expression: Expression): DoStatement

updateElementAccessChain

abstract fun updateElementAccessChain( node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken?, argumentExpression: Expression): ElementAccessChain

updateElementAccessExpression

abstract fun updateElementAccessExpression( node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression

updateEnumDeclaration

abstract fun updateEnumDeclaration( node: EnumDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: Identifier, members: <Error class: unknown class><EnumMember>): EnumDeclaration

updateEnumMember

abstract fun updateEnumMember(node: EnumMember, name: PropertyName, initializer: Expression?): EnumMember

updateExportAssignment

abstract fun updateExportAssignment( node: ExportAssignment, modifiers: <Error class: unknown class><ModifierLike>?, expression: Expression): ExportAssignment

updateExportDeclaration

abstract fun updateExportDeclaration( node: ExportDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, isTypeOnly: Boolean, exportClause: NamedExportBindings?, moduleSpecifier: Expression?, attributes: ImportAttributes?): ExportDeclaration

updateExportSpecifier

abstract fun updateExportSpecifier( node: ExportSpecifier, isTypeOnly: Boolean, propertyName: ModuleExportName?, name: ModuleExportName): ExportSpecifier

updateExpressionStatement

abstract fun updateExpressionStatement(node: ExpressionStatement, expression: Expression): ExpressionStatement

updateExpressionWithTypeArguments

abstract fun updateExpressionWithTypeArguments( node: ExpressionWithTypeArguments, expression: Expression, typeArguments: <Error class: unknown class><TypeNode>?): ExpressionWithTypeArguments

updateExternalModuleReference

abstract fun updateExternalModuleReference(node: ExternalModuleReference, expression: Expression): ExternalModuleReference

updateForInStatement

abstract fun updateForInStatement(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement

updateForOfStatement

abstract fun updateForOfStatement( node: ForOfStatement, awaitModifier: AwaitKeyword?, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement

updateForStatement

abstract fun updateForStatement( node: ForStatement, initializer: ForInitializer?, condition: Expression?, incrementor: Expression?, statement: Statement): ForStatement

updateFunctionDeclaration

abstract fun updateFunctionDeclaration( node: FunctionDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, asteriskToken: AsteriskToken?, name: Identifier?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, body: Block?): FunctionDeclaration

updateFunctionExpression

abstract fun updateFunctionExpression( node: FunctionExpression, modifiers: <Error class: unknown class><Modifier>?, asteriskToken: AsteriskToken?, name: Identifier?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, body: Block): FunctionExpression

updateFunctionTypeNode

abstract fun updateFunctionTypeNode( node: FunctionTypeNode, typeParameters: NodeArray<TypeParameterDeclaration>?, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): FunctionTypeNode

updateGetAccessorDeclaration

abstract fun updateGetAccessorDeclaration( node: GetAccessorDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: PropertyName, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, body: Block?): GetAccessorDeclaration

updateHeritageClause

abstract fun updateHeritageClause(node: HeritageClause, types: <Error class: unknown class><ExpressionWithTypeArguments>): HeritageClause

updateIfStatement

abstract fun updateIfStatement(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement?): IfStatement

updateImportAttribute

abstract fun updateImportAttribute(node: ImportAttribute, name: ImportAttributeName, value: Expression): ImportAttribute

updateImportAttributes

abstract fun updateImportAttributes( node: ImportAttributes, elements: NodeArray<ImportAttribute>, multiLine: Boolean = definedExternally): ImportAttributes

updateImportClause

abstract fun updateImportClause(node: ImportClause, isTypeOnly: Boolean, name: Identifier?, namedBindings: NamedImportBindings?): ImportClause

updateImportDeclaration

abstract fun updateImportDeclaration( node: ImportDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, importClause: ImportClause?, moduleSpecifier: Expression, attributes: ImportAttributes?): ImportDeclaration

updateImportEqualsDeclaration

abstract fun updateImportEqualsDeclaration( node: ImportEqualsDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, isTypeOnly: Boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration

updateImportSpecifier

abstract fun updateImportSpecifier( node: ImportSpecifier, isTypeOnly: Boolean, propertyName: ModuleExportName?, name: Identifier): ImportSpecifier

updateImportTypeAssertionContainer

abstract fun updateImportTypeAssertionContainer( node: ImportTypeAssertionContainer, clause: AssertClause, multiLine: Boolean = definedExternally): ImportTypeAssertionContainer

updateImportTypeNode

abstract fun updateImportTypeNode( node: ImportTypeNode, argument: TypeNode, attributes: ImportAttributes?, qualifier: EntityName?, typeArguments: <Error class: unknown class><TypeNode>?, isTypeOf: Boolean = definedExternally): ImportTypeNode

updateIndexedAccessTypeNode

abstract fun updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode

updateIndexSignature

abstract fun updateIndexSignature( node: IndexSignatureDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode): IndexSignatureDeclaration

updateInferTypeNode

abstract fun updateInferTypeNode(node: InferTypeNode, typeParameter: TypeParameterDeclaration): InferTypeNode

updateInterfaceDeclaration

abstract fun updateInterfaceDeclaration( node: InterfaceDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: Identifier, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, heritageClauses: <Error class: unknown class><HeritageClause>?, members: <Error class: unknown class><TypeElement>): InterfaceDeclaration

updateIntersectionTypeNode

abstract fun updateIntersectionTypeNode(node: IntersectionTypeNode, types: NodeArray<TypeNode>): IntersectionTypeNode

updateJSDocAugmentsTag

abstract fun updateJSDocAugmentsTag( node: JSDocAugmentsTag, tagName: Identifier?, className: JSDocAugmentsTagClass, comment: String?): JSDocAugmentsTag

abstract fun updateJSDocAugmentsTag( node: JSDocAugmentsTag, tagName: Identifier?, className: JSDocAugmentsTagClass, comment: NodeArray<JSDocComment>?): JSDocAugmentsTag

updateJSDocAuthorTag

abstract fun updateJSDocAuthorTag(node: JSDocAuthorTag, tagName: Identifier?, comment: String?): JSDocAuthorTag

abstract fun updateJSDocAuthorTag(node: JSDocAuthorTag, tagName: Identifier?, comment: NodeArray<JSDocComment>?): JSDocAuthorTag

updateJSDocCallbackTag

abstract fun updateJSDocCallbackTag( node: JSDocCallbackTag, tagName: Identifier?, typeExpression: JSDocSignature, fullName: Identifier?, comment: String?): JSDocCallbackTag

abstract fun updateJSDocCallbackTag( node: JSDocCallbackTag, tagName: Identifier?, typeExpression: JSDocSignature, fullName: Identifier?, comment: NodeArray<JSDocComment>?): JSDocCallbackTag

abstract fun updateJSDocCallbackTag( node: JSDocCallbackTag, tagName: Identifier?, typeExpression: JSDocSignature, fullName: JSDocNamespaceDeclaration?, comment: String?): JSDocCallbackTag

abstract fun updateJSDocCallbackTag( node: JSDocCallbackTag, tagName: Identifier?, typeExpression: JSDocSignature, fullName: JSDocNamespaceDeclaration?, comment: NodeArray<JSDocComment>?): JSDocCallbackTag

updateJSDocClassTag

abstract fun updateJSDocClassTag(node: JSDocClassTag, tagName: Identifier?, comment: String?): JSDocClassTag

abstract fun updateJSDocClassTag(node: JSDocClassTag, tagName: Identifier?, comment: NodeArray<JSDocComment>?): JSDocClassTag

updateJSDocComment

abstract fun updateJSDocComment(node: JSDoc, comment: String?, tags: <Error class: unknown class><JSDocTag>?): JSDoc

abstract fun updateJSDocComment(node: JSDoc, comment: NodeArray<JSDocComment>?, tags: <Error class: unknown class><JSDocTag>?): JSDoc

updateJSDocDeprecatedTag

abstract fun updateJSDocDeprecatedTag(node: JSDocDeprecatedTag, tagName: Identifier?): JSDocDeprecatedTag

abstract fun updateJSDocDeprecatedTag( node: JSDocDeprecatedTag, tagName: Identifier?, comment: String = definedExternally): JSDocDeprecatedTag

abstract fun updateJSDocDeprecatedTag( node: JSDocDeprecatedTag, tagName: Identifier?, comment: NodeArray<JSDocComment> = definedExternally): JSDocDeprecatedTag

updateJSDocEnumTag

abstract fun updateJSDocEnumTag( node: JSDocEnumTag, tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: String?): JSDocEnumTag

abstract fun updateJSDocEnumTag( node: JSDocEnumTag, tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: NodeArray<JSDocComment>?): JSDocEnumTag

updateJSDocFunctionType

abstract fun updateJSDocFunctionType( node: JSDocFunctionType, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?): JSDocFunctionType

updateJSDocImplementsTag

abstract fun updateJSDocImplementsTag( node: JSDocImplementsTag, tagName: Identifier?, className: JSDocImplementsTagClass, comment: String?): JSDocImplementsTag

abstract fun updateJSDocImplementsTag( node: JSDocImplementsTag, tagName: Identifier?, className: JSDocImplementsTagClass, comment: NodeArray<JSDocComment>?): JSDocImplementsTag

updateJSDocImportTag

abstract fun updateJSDocImportTag( node: JSDocImportTag, tagName: Identifier?, importClause: ImportClause?, moduleSpecifier: Expression, attributes: ImportAttributes?, comment: String?): JSDocImportTag

updateJSDocLink

abstract fun updateJSDocLink(node: JSDocLink, name: EntityName?, text: String): JSDocLink

abstract fun updateJSDocLink(node: JSDocLink, name: JSDocMemberName?, text: String): JSDocLink

updateJSDocLinkCode

abstract fun updateJSDocLinkCode(node: JSDocLinkCode, name: EntityName?, text: String): JSDocLinkCode

abstract fun updateJSDocLinkCode(node: JSDocLinkCode, name: JSDocMemberName?, text: String): JSDocLinkCode

updateJSDocLinkPlain

abstract fun updateJSDocLinkPlain(node: JSDocLinkPlain, name: EntityName?, text: String): JSDocLinkPlain

abstract fun updateJSDocLinkPlain(node: JSDocLinkPlain, name: JSDocMemberName?, text: String): JSDocLinkPlain

updateJSDocMemberName

abstract fun updateJSDocMemberName(node: JSDocMemberName, left: EntityName, right: Identifier): JSDocMemberName

abstract fun updateJSDocMemberName(node: JSDocMemberName, left: JSDocMemberName, right: Identifier): JSDocMemberName

updateJSDocNamepathType

abstract fun updateJSDocNamepathType(node: JSDocNamepathType, type: TypeNode): JSDocNamepathType

updateJSDocNameReference

abstract fun updateJSDocNameReference(node: JSDocNameReference, name: EntityName): JSDocNameReference

abstract fun updateJSDocNameReference(node: JSDocNameReference, name: JSDocMemberName): JSDocNameReference

updateJSDocNonNullableType

abstract fun updateJSDocNonNullableType(node: JSDocNonNullableType, type: TypeNode): JSDocNonNullableType

updateJSDocNullableType

abstract fun updateJSDocNullableType(node: JSDocNullableType, type: TypeNode): JSDocNullableType

updateJSDocOptionalType

abstract fun updateJSDocOptionalType(node: JSDocOptionalType, type: TypeNode): JSDocOptionalType

updateJSDocOverloadTag

abstract fun updateJSDocOverloadTag( node: JSDocOverloadTag, tagName: Identifier?, typeExpression: JSDocSignature, comment: String?): JSDocOverloadTag

abstract fun updateJSDocOverloadTag( node: JSDocOverloadTag, tagName: Identifier?, typeExpression: JSDocSignature, comment: NodeArray<JSDocComment>?): JSDocOverloadTag

updateJSDocOverrideTag

abstract fun updateJSDocOverrideTag(node: JSDocOverrideTag, tagName: Identifier?): JSDocOverrideTag

abstract fun updateJSDocOverrideTag(node: JSDocOverrideTag, tagName: Identifier?, comment: String = definedExternally): JSDocOverrideTag

abstract fun updateJSDocOverrideTag( node: JSDocOverrideTag, tagName: Identifier?, comment: NodeArray<JSDocComment> = definedExternally): JSDocOverrideTag

updateJSDocParameterTag

abstract fun updateJSDocParameterTag( node: JSDocParameterTag, tagName: Identifier?, name: EntityName, isBracketed: Boolean, typeExpression: JSDocTypeExpression?, isNameFirst: Boolean, comment: String?): JSDocParameterTag

updateJSDocPrivateTag

abstract fun updateJSDocPrivateTag(node: JSDocPrivateTag, tagName: Identifier?, comment: String?): JSDocPrivateTag

abstract fun updateJSDocPrivateTag(node: JSDocPrivateTag, tagName: Identifier?, comment: NodeArray<JSDocComment>?): JSDocPrivateTag

updateJSDocPropertyTag

abstract fun updateJSDocPropertyTag( node: JSDocPropertyTag, tagName: Identifier?, name: EntityName, isBracketed: Boolean, typeExpression: JSDocTypeExpression?, isNameFirst: Boolean, comment: String?): JSDocPropertyTag

updateJSDocProtectedTag

abstract fun updateJSDocProtectedTag(node: JSDocProtectedTag, tagName: Identifier?, comment: String?): JSDocProtectedTag

abstract fun updateJSDocProtectedTag(node: JSDocProtectedTag, tagName: Identifier?, comment: NodeArray<JSDocComment>?): JSDocProtectedTag

updateJSDocPublicTag

abstract fun updateJSDocPublicTag(node: JSDocPublicTag, tagName: Identifier?, comment: String?): JSDocPublicTag

abstract fun updateJSDocPublicTag(node: JSDocPublicTag, tagName: Identifier?, comment: NodeArray<JSDocComment>?): JSDocPublicTag

updateJSDocReadonlyTag

abstract fun updateJSDocReadonlyTag(node: JSDocReadonlyTag, tagName: Identifier?, comment: String?): JSDocReadonlyTag

abstract fun updateJSDocReadonlyTag(node: JSDocReadonlyTag, tagName: Identifier?, comment: NodeArray<JSDocComment>?): JSDocReadonlyTag

updateJSDocReturnTag

abstract fun updateJSDocReturnTag( node: JSDocReturnTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?, comment: String?): JSDocReturnTag

abstract fun updateJSDocReturnTag( node: JSDocReturnTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?, comment: NodeArray<JSDocComment>?): JSDocReturnTag

updateJSDocSatisfiesTag

abstract fun updateJSDocSatisfiesTag( node: JSDocSatisfiesTag, tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: String?): JSDocSatisfiesTag

abstract fun updateJSDocSatisfiesTag( node: JSDocSatisfiesTag, tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: NodeArray<JSDocComment>?): JSDocSatisfiesTag

updateJSDocSeeTag

abstract fun updateJSDocSeeTag(node: JSDocSeeTag, tagName: Identifier?, nameExpression: JSDocNameReference?): JSDocSeeTag

abstract fun updateJSDocSeeTag( node: JSDocSeeTag, tagName: Identifier?, nameExpression: JSDocNameReference?, comment: String = definedExternally): JSDocSeeTag

abstract fun updateJSDocSeeTag( node: JSDocSeeTag, tagName: Identifier?, nameExpression: JSDocNameReference?, comment: NodeArray<JSDocComment> = definedExternally): JSDocSeeTag

updateJSDocSignature

abstract fun updateJSDocSignature( node: JSDocSignature, typeParameters: <Error class: unknown class><JSDocTemplateTag>?, parameters: <Error class: unknown class><JSDocParameterTag>, type: JSDocReturnTag?): JSDocSignature

updateJSDocTemplateTag

abstract fun updateJSDocTemplateTag( node: JSDocTemplateTag, tagName: Identifier?, constraint: JSDocTypeExpression?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>, comment: String?): JSDocTemplateTag

updateJSDocText

abstract fun updateJSDocText(node: JSDocText, text: String): JSDocText

updateJSDocThisTag

abstract fun updateJSDocThisTag(node: JSDocThisTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?, comment: String?): JSDocThisTag

abstract fun updateJSDocThisTag( node: JSDocThisTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?, comment: NodeArray<JSDocComment>?): JSDocThisTag

updateJSDocThrowsTag

abstract fun updateJSDocThrowsTag(node: JSDocThrowsTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?): JSDocThrowsTag

abstract fun updateJSDocThrowsTag( node: JSDocThrowsTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?, comment: String? = definedExternally): JSDocThrowsTag

abstract fun updateJSDocThrowsTag( node: JSDocThrowsTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?, comment: NodeArray<JSDocComment>? = definedExternally): JSDocThrowsTag

updateJSDocTypedefTag

abstract fun updateJSDocTypedefTag( node: JSDocTypedefTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?, fullName: Identifier?, comment: String?): JSDocTypedefTag

abstract fun updateJSDocTypedefTag( node: JSDocTypedefTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?, fullName: Identifier?, comment: NodeArray<JSDocComment>?): JSDocTypedefTag

abstract fun updateJSDocTypedefTag( node: JSDocTypedefTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?, fullName: JSDocNamespaceDeclaration?, comment: String?): JSDocTypedefTag

abstract fun updateJSDocTypedefTag( node: JSDocTypedefTag, tagName: Identifier?, typeExpression: JSDocTypeExpression?, fullName: JSDocNamespaceDeclaration?, comment: NodeArray<JSDocComment>?): JSDocTypedefTag

abstract fun updateJSDocTypedefTag( node: JSDocTypedefTag, tagName: Identifier?, typeExpression: JSDocTypeLiteral?, fullName: Identifier?, comment: String?): JSDocTypedefTag

abstract fun updateJSDocTypedefTag( node: JSDocTypedefTag, tagName: Identifier?, typeExpression: JSDocTypeLiteral?, fullName: Identifier?, comment: NodeArray<JSDocComment>?): JSDocTypedefTag

abstract fun updateJSDocTypedefTag( node: JSDocTypedefTag, tagName: Identifier?, typeExpression: JSDocTypeLiteral?, fullName: JSDocNamespaceDeclaration?, comment: String?): JSDocTypedefTag

abstract fun updateJSDocTypedefTag( node: JSDocTypedefTag, tagName: Identifier?, typeExpression: JSDocTypeLiteral?, fullName: JSDocNamespaceDeclaration?, comment: NodeArray<JSDocComment>?): JSDocTypedefTag

updateJSDocTypeExpression

abstract fun updateJSDocTypeExpression(node: JSDocTypeExpression, type: TypeNode): JSDocTypeExpression

updateJSDocTypeLiteral

abstract fun updateJSDocTypeLiteral( node: JSDocTypeLiteral, jsDocPropertyTags: <Error class: unknown class><JSDocPropertyLikeTag>?, isArrayType: Boolean?): JSDocTypeLiteral

updateJSDocTypeTag

abstract fun updateJSDocTypeTag(node: JSDocTypeTag, tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: String?): JSDocTypeTag

abstract fun updateJSDocTypeTag( node: JSDocTypeTag, tagName: Identifier?, typeExpression: JSDocTypeExpression, comment: NodeArray<JSDocComment>?): JSDocTypeTag

updateJSDocUnknownTag

abstract fun updateJSDocUnknownTag(node: JSDocUnknownTag, tagName: Identifier, comment: String?): JSDocUnknownTag

abstract fun updateJSDocUnknownTag(node: JSDocUnknownTag, tagName: Identifier, comment: NodeArray<JSDocComment>?): JSDocUnknownTag

updateJSDocVariadicType

abstract fun updateJSDocVariadicType(node: JSDocVariadicType, type: TypeNode): JSDocVariadicType

updateJsxAttribute

abstract fun updateJsxAttribute(node: JsxAttribute, name: JsxAttributeName, initializer: JsxAttributeValue?): JsxAttribute

updateJsxAttributes

abstract fun updateJsxAttributes(node: JsxAttributes, properties: <Error class: unknown class><JsxAttributeLike>): JsxAttributes

updateJsxClosingElement

abstract fun updateJsxClosingElement(node: JsxClosingElement, tagName: JsxTagNameExpression): JsxClosingElement

updateJsxElement

abstract fun updateJsxElement( node: JsxElement, openingElement: JsxOpeningElement, children: <Error class: unknown class><JsxChild>, closingElement: JsxClosingElement): JsxElement

updateJsxExpression

abstract fun updateJsxExpression(node: JsxExpression, expression: Expression?): JsxExpression

updateJsxFragment

abstract fun updateJsxFragment( node: JsxFragment, openingFragment: JsxOpeningFragment, children: <Error class: unknown class><JsxChild>, closingFragment: JsxClosingFragment): JsxFragment

updateJsxNamespacedName

abstract fun updateJsxNamespacedName(node: JsxNamespacedName, namespace: Identifier, name: Identifier): JsxNamespacedName

updateJsxOpeningElement

abstract fun updateJsxOpeningElement( node: JsxOpeningElement, tagName: JsxTagNameExpression, typeArguments: <Error class: unknown class><TypeNode>?, attributes: JsxAttributes): JsxOpeningElement

updateJsxSelfClosingElement

abstract fun updateJsxSelfClosingElement( node: JsxSelfClosingElement, tagName: JsxTagNameExpression, typeArguments: <Error class: unknown class><TypeNode>?, attributes: JsxAttributes): JsxSelfClosingElement

updateJsxSpreadAttribute

abstract fun updateJsxSpreadAttribute(node: JsxSpreadAttribute, expression: Expression): JsxSpreadAttribute

updateJsxText

abstract fun updateJsxText(node: JsxText, text: String, containsOnlyTriviaWhiteSpaces: Boolean = definedExternally): JsxText

updateLabeledStatement

abstract fun updateLabeledStatement(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement

updateLiteralTypeNode

abstract fun updateLiteralTypeNode(node: LiteralTypeNode, literal: NodeFactoryUpdateLiteralTypeNodeLiteral): LiteralTypeNode

updateMappedTypeNode

abstract fun updateMappedTypeNode( node: MappedTypeNode, readonlyToken: ReadonlyKeyword?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: MinusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun updateMappedTypeNode( node: MappedTypeNode, readonlyToken: ReadonlyKeyword?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: PlusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun updateMappedTypeNode( node: MappedTypeNode, readonlyToken: ReadonlyKeyword?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: QuestionToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun updateMappedTypeNode( node: MappedTypeNode, readonlyToken: MinusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: MinusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun updateMappedTypeNode( node: MappedTypeNode, readonlyToken: MinusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: PlusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun updateMappedTypeNode( node: MappedTypeNode, readonlyToken: MinusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: QuestionToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun updateMappedTypeNode( node: MappedTypeNode, readonlyToken: PlusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: MinusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun updateMappedTypeNode( node: MappedTypeNode, readonlyToken: PlusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: PlusToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

abstract fun updateMappedTypeNode( node: MappedTypeNode, readonlyToken: PlusToken?, typeParameter: TypeParameterDeclaration, nameType: TypeNode?, questionToken: QuestionToken?, type: TypeNode?, members: NodeArray<TypeElement>?): MappedTypeNode

updateMetaProperty

abstract fun updateMetaProperty(node: MetaProperty, name: Identifier): MetaProperty

updateMethodDeclaration

abstract fun updateMethodDeclaration( node: MethodDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, asteriskToken: AsteriskToken?, name: PropertyName, questionToken: QuestionToken?, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, parameters: <Error class: unknown class><ParameterDeclaration>, type: TypeNode?, body: Block?): MethodDeclaration

updateMethodSignature

abstract fun updateMethodSignature( node: MethodSignature, modifiers: <Error class: unknown class><Modifier>?, name: PropertyName, questionToken: QuestionToken?, typeParameters: NodeArray<TypeParameterDeclaration>?, parameters: NodeArray<ParameterDeclaration>, type: TypeNode?): MethodSignature

updateModuleBlock

abstract fun updateModuleBlock(node: ModuleBlock, statements: <Error class: unknown class><Statement>): ModuleBlock

updateModuleDeclaration

abstract fun updateModuleDeclaration( node: ModuleDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: ModuleName, body: ModuleBody?): ModuleDeclaration

updateNamedExports

abstract fun updateNamedExports(node: NamedExports, elements: <Error class: unknown class><ExportSpecifier>): NamedExports

updateNamedImports

abstract fun updateNamedImports(node: NamedImports, elements: <Error class: unknown class><ImportSpecifier>): NamedImports

updateNamedTupleMember

abstract fun updateNamedTupleMember( node: NamedTupleMember, dotDotDotToken: DotDotDotToken?, name: Identifier, questionToken: QuestionToken?, type: TypeNode): NamedTupleMember

updateNamespaceExport

abstract fun updateNamespaceExport(node: NamespaceExport, name: ModuleExportName): NamespaceExport

updateNamespaceExportDeclaration

abstract fun updateNamespaceExportDeclaration(node: NamespaceExportDeclaration, name: Identifier): NamespaceExportDeclaration

updateNamespaceImport

abstract fun updateNamespaceImport(node: NamespaceImport, name: Identifier): NamespaceImport

updateNewExpression

abstract fun updateNewExpression( node: NewExpression, expression: Expression, typeArguments: <Error class: unknown class><TypeNode>?, argumentsArray: <Error class: unknown class><Expression>?): NewExpression

updateNonNullChain

abstract fun updateNonNullChain(node: NonNullChain, expression: Expression): NonNullChain

updateNonNullExpression

abstract fun updateNonNullExpression(node: NonNullExpression, expression: Expression): NonNullExpression

updateObjectBindingPattern

abstract fun updateObjectBindingPattern( node: ObjectBindingPattern, elements: <Error class: unknown class><BindingElement>): ObjectBindingPattern

updateObjectLiteralExpression

abstract fun updateObjectLiteralExpression( node: ObjectLiteralExpression, properties: <Error class: unknown class><ObjectLiteralElementLike>): ObjectLiteralExpression

updateOptionalTypeNode

abstract fun updateOptionalTypeNode(node: OptionalTypeNode, type: TypeNode): OptionalTypeNode

updateParameterDeclaration

abstract fun updateParameterDeclaration( node: ParameterDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, dotDotDotToken: DotDotDotToken?, name: String, questionToken: QuestionToken?, type: TypeNode?, initializer: Expression?): ParameterDeclaration

abstract fun updateParameterDeclaration( node: ParameterDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, dotDotDotToken: DotDotDotToken?, name: BindingName, questionToken: QuestionToken?, type: TypeNode?, initializer: Expression?): ParameterDeclaration

updateParenthesizedExpression

abstract fun updateParenthesizedExpression(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression

updateParenthesizedType

abstract fun updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode

updatePartiallyEmittedExpression

abstract fun updatePartiallyEmittedExpression(node: PartiallyEmittedExpression, expression: Expression): PartiallyEmittedExpression

updatePostfixUnaryExpression

abstract fun updatePostfixUnaryExpression(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression

updatePrefixUnaryExpression

abstract fun updatePrefixUnaryExpression(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression

updatePropertyAccessChain

abstract fun updatePropertyAccessChain( node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken?, name: MemberName): PropertyAccessChain

updatePropertyAccessExpression

abstract fun updatePropertyAccessExpression( node: PropertyAccessExpression, expression: Expression, name: MemberName): PropertyAccessExpression

updatePropertyAssignment

abstract fun updatePropertyAssignment(node: PropertyAssignment, name: PropertyName, initializer: Expression): PropertyAssignment

updatePropertyDeclaration

abstract fun updatePropertyDeclaration( node: PropertyDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: String, questionOrExclamationToken: ExclamationToken?, type: TypeNode?, initializer: Expression?): PropertyDeclaration

abstract fun updatePropertyDeclaration( node: PropertyDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: String, questionOrExclamationToken: QuestionToken?, type: TypeNode?, initializer: Expression?): PropertyDeclaration

abstract fun updatePropertyDeclaration( node: PropertyDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: PropertyName, questionOrExclamationToken: ExclamationToken?, type: TypeNode?, initializer: Expression?): PropertyDeclaration

abstract fun updatePropertyDeclaration( node: PropertyDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: PropertyName, questionOrExclamationToken: QuestionToken?, type: TypeNode?, initializer: Expression?): PropertyDeclaration

updatePropertySignature

abstract fun updatePropertySignature( node: PropertySignature, modifiers: <Error class: unknown class><Modifier>?, name: PropertyName, questionToken: QuestionToken?, type: TypeNode?): PropertySignature

updateQualifiedName

abstract fun updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier): QualifiedName

updateRestTypeNode

abstract fun updateRestTypeNode(node: RestTypeNode, type: TypeNode): RestTypeNode

updateReturnStatement

abstract fun updateReturnStatement(node: ReturnStatement, expression: Expression?): ReturnStatement

updateSatisfiesExpression

abstract fun updateSatisfiesExpression(node: SatisfiesExpression, expression: Expression, type: TypeNode): SatisfiesExpression

updateSetAccessorDeclaration

abstract fun updateSetAccessorDeclaration( node: SetAccessorDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: PropertyName, parameters: <Error class: unknown class><ParameterDeclaration>, body: Block?): SetAccessorDeclaration

updateShorthandPropertyAssignment

abstract fun updateShorthandPropertyAssignment( node: ShorthandPropertyAssignment, name: Identifier, objectAssignmentInitializer: Expression?): ShorthandPropertyAssignment

updateSourceFile

abstract fun updateSourceFile( node: SourceFile, statements: <Error class: unknown class><Statement>, isDeclarationFile: Boolean = definedExternally, referencedFiles: <Error class: unknown class><FileReference> = definedExternally, typeReferences: <Error class: unknown class><FileReference> = definedExternally, hasNoDefaultLib: Boolean = definedExternally, libReferences: <Error class: unknown class><FileReference> = definedExternally): SourceFile

updateSpreadAssignment

abstract fun updateSpreadAssignment(node: SpreadAssignment, expression: Expression): SpreadAssignment

updateSpreadElement

abstract fun updateSpreadElement(node: SpreadElement, expression: Expression): SpreadElement

updateSwitchStatement

abstract fun updateSwitchStatement(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement

updateTaggedTemplateExpression

abstract fun updateTaggedTemplateExpression( node: TaggedTemplateExpression, tag: Expression, typeArguments: <Error class: unknown class><TypeNode>?, template: TemplateLiteral): TaggedTemplateExpression

updateTemplateExpression

abstract fun updateTemplateExpression( node: TemplateExpression, head: TemplateHead, templateSpans: <Error class: unknown class><TemplateSpan>): TemplateExpression

updateTemplateLiteralType

abstract fun updateTemplateLiteralType( node: TemplateLiteralTypeNode, head: TemplateHead, templateSpans: <Error class: unknown class><TemplateLiteralTypeSpan>): TemplateLiteralTypeNode

updateTemplateLiteralTypeSpan

abstract fun updateTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle): TemplateLiteralTypeSpan

abstract fun updateTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateTail): TemplateLiteralTypeSpan

updateTemplateSpan

abstract fun updateTemplateSpan(node: TemplateSpan, expression: Expression, literal: TemplateMiddle): TemplateSpan

abstract fun updateTemplateSpan(node: TemplateSpan, expression: Expression, literal: TemplateTail): TemplateSpan

updateThrowStatement

abstract fun updateThrowStatement(node: ThrowStatement, expression: Expression): ThrowStatement

updateTryStatement

abstract fun updateTryStatement(node: TryStatement, tryBlock: Block, catchClause: CatchClause?, finallyBlock: Block?): TryStatement

updateTupleTypeNode

abstract fun updateTupleTypeNode( node: TupleTypeNode, elements: <Error class: unknown class><NodeFactoryUpdateTupleTypeNodeElementsItem>): TupleTypeNode

updateTypeAliasDeclaration

abstract fun updateTypeAliasDeclaration( node: TypeAliasDeclaration, modifiers: <Error class: unknown class><ModifierLike>?, name: Identifier, typeParameters: <Error class: unknown class><TypeParameterDeclaration>?, type: TypeNode): TypeAliasDeclaration

updateTypeAssertion

abstract fun updateTypeAssertion(node: TypeAssertion, type: TypeNode, expression: Expression): TypeAssertion

updateTypeLiteralNode

abstract fun updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray<TypeElement>): TypeLiteralNode

updateTypeOfExpression

abstract fun updateTypeOfExpression(node: TypeOfExpression, expression: Expression): TypeOfExpression

updateTypeOperatorNode

abstract fun updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode

updateTypeParameterDeclaration

abstract fun updateTypeParameterDeclaration( node: TypeParameterDeclaration, modifiers: <Error class: unknown class><Modifier>?, name: Identifier, constraint: TypeNode?, defaultType: TypeNode?): TypeParameterDeclaration

updateTypePredicateNode

abstract fun updateTypePredicateNode( node: TypePredicateNode, assertsModifier: AssertsKeyword?, parameterName: Identifier, type: TypeNode?): TypePredicateNode

abstract fun updateTypePredicateNode( node: TypePredicateNode, assertsModifier: AssertsKeyword?, parameterName: ThisTypeNode, type: TypeNode?): TypePredicateNode

updateTypeQueryNode

abstract fun updateTypeQueryNode( node: TypeQueryNode, exprName: EntityName, typeArguments: <Error class: unknown class><TypeNode> = definedExternally): TypeQueryNode

updateTypeReferenceNode

abstract fun updateTypeReferenceNode( node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode>?): TypeReferenceNode

updateUnionTypeNode

abstract fun updateUnionTypeNode(node: UnionTypeNode, types: NodeArray<TypeNode>): UnionTypeNode

updateVariableDeclaration

abstract fun updateVariableDeclaration( node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken?, type: TypeNode?, initializer: Expression?): VariableDeclaration

updateVariableDeclarationList

abstract fun updateVariableDeclarationList( node: VariableDeclarationList, declarations: <Error class: unknown class><VariableDeclaration>): VariableDeclarationList

updateVariableStatement

abstract fun updateVariableStatement( node: VariableStatement, modifiers: <Error class: unknown class><ModifierLike>?, declarationList: VariableDeclarationList): VariableStatement

updateVoidExpression

abstract fun updateVoidExpression(node: VoidExpression, expression: Expression): VoidExpression

updateWhileStatement

abstract fun updateWhileStatement(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement

updateWithStatement

abstract fun updateWithStatement(node: WithStatement, expression: Expression, statement: Statement): WithStatement

updateYieldExpression

abstract fun updateYieldExpression(node: YieldExpression, asteriskToken: AsteriskToken?, expression: Expression?): YieldExpression