kotlin-typescript/typescript/NodeFactory

NodeFactory

sealed external interface NodeFactory(source)

Functions

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

abstract fun createArrayBindingPattern(elements: ReadonlyArray<ArrayBindingElement>): ArrayBindingPattern

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

createArrayTypeNode

abstract fun createArrayTypeNode(elementType: TypeNode): ArrayTypeNode

createArrowFunction

abstract fun createArrowFunction(modifiers: ReadonlyArray<Modifier>?, typeParameters: ReadonlyArray<TypeParameterDeclaration>?, parameters: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<SourceFile>): Bundle

abstract fun createBundle(sourceFiles: ReadonlyArray<SourceFile>, prepends: ReadonlyArray<NodeFactoryCreateBundlePrependsItem> = definedExternally): Bundle

createCallChain

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

createCallExpression

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

createCallSignature

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

createCaseBlock

abstract fun createCaseBlock(clauses: ReadonlyArray<CaseOrDefaultClause>): CaseBlock

createCaseClause

abstract fun createCaseClause(expression: Expression, statements: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, name: String?, typeParameters: ReadonlyArray<TypeParameterDeclaration>?, heritageClauses: ReadonlyArray<HeritageClause>?, members: ReadonlyArray<ClassElement>): ClassDeclaration

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

createClassExpression

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

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

createClassStaticBlockDeclaration

abstract fun createClassStaticBlockDeclaration(body: Block): ClassStaticBlockDeclaration

createComma

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

createCommaListExpression

abstract fun createCommaListExpression(elements: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, parameters: ReadonlyArray<ParameterDeclaration>, body: Block?): ConstructorDeclaration

createConstructorTypeNode

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

createConstructSignature

abstract fun createConstructSignature(typeParameters: ReadonlyArray<TypeParameterDeclaration>?, parameters: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, name: String, members: ReadonlyArray<EnumMember>): EnumDeclaration

abstract fun createEnumDeclaration(modifiers: ReadonlyArray<ModifierLike>?, name: Identifier, members: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, isExportEquals: Boolean?, expression: Expression): ExportAssignment

createExportDeclaration

abstract fun createExportDeclaration(modifiers: ReadonlyArray<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: Identifier): ExportSpecifier

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

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

createExpressionStatement

abstract fun createExpressionStatement(expression: Expression): ExpressionStatement

createExpressionWithTypeArguments

abstract fun createExpressionWithTypeArguments(expression: Expression, typeArguments: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, asteriskToken: AsteriskToken?, name: String?, typeParameters: ReadonlyArray<TypeParameterDeclaration>?, parameters: ReadonlyArray<ParameterDeclaration>, type: TypeNode?, body: Block?): FunctionDeclaration

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

createFunctionExpression

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

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

createFunctionTypeNode

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

createGetAccessorDeclaration

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

abstract fun createGetAccessorDeclaration(modifiers: ReadonlyArray<ModifierLike>?, name: PropertyName, parameters: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<Statement>): ImmediatelyInvokedArrowFunction

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

createImmediatelyInvokedFunctionExpression

abstract fun createImmediatelyInvokedFunctionExpression(statements: ReadonlyArray<Statement>): CallExpression

abstract fun createImmediatelyInvokedFunctionExpression(statements: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, importClause: ImportClause?, moduleSpecifier: Expression, attributes: ImportAttributes = definedExternally): ImportDeclaration

createImportEqualsDeclaration

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

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

createImportSpecifier

abstract fun createImportSpecifier(isTypeOnly: Boolean, propertyName: Identifier?, 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: ReadonlyArray<TypeNode> = definedExternally, isTypeOf: Boolean = definedExternally): ImportTypeNode

createIndexedAccessTypeNode

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

createIndexSignature

abstract fun createIndexSignature(modifiers: ReadonlyArray<ModifierLike>?, parameters: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, name: String, typeParameters: ReadonlyArray<TypeParameterDeclaration>?, heritageClauses: ReadonlyArray<HeritageClause>?, members: ReadonlyArray<TypeElement>): InterfaceDeclaration

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

createIntersectionTypeNode

abstract fun createIntersectionTypeNode(types: ReadonlyArray<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: ReadonlyArray<JSDocTag>? = definedExternally): JSDoc

abstract fun createJSDocComment(comment: NodeArray<JSDocComment>? = definedExternally, tags: ReadonlyArray<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: ReadonlyArray<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

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: ReadonlyArray<JSDocTemplateTag>?, parameters: ReadonlyArray<JSDocParameterTag>, type: JSDocReturnTag = definedExternally): JSDocSignature

createJSDocTemplateTag

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

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

abstract fun createJSDocTemplateTag(tagName: Identifier?, constraint: JSDocTypeExpression?, typeParameters: ReadonlyArray<TypeParameterDeclaration>, comment: NodeArray<JSDocComment> = 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: ReadonlyArray<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: ReadonlyArray<JsxAttributeLike>): JsxAttributes

createJsxClosingElement

abstract fun createJsxClosingElement(tagName: JsxTagNameExpression): JsxClosingElement

createJsxElement

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

createJsxExpression

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

createJsxFragment

abstract fun createJsxFragment(openingFragment: JsxOpeningFragment, children: ReadonlyArray<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: ReadonlyArray<TypeNode>?, attributes: JsxAttributes): JsxOpeningElement

createJsxOpeningFragment

abstract fun createJsxOpeningFragment(): JsxOpeningFragment

createJsxSelfClosingElement

abstract fun createJsxSelfClosingElement(tagName: JsxTagNameExpression, typeArguments: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, asteriskToken: AsteriskToken?, name: String, questionToken: QuestionToken?, typeParameters: ReadonlyArray<TypeParameterDeclaration>?, parameters: ReadonlyArray<ParameterDeclaration>, type: TypeNode?, body: Block?): MethodDeclaration

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

createMethodSignature

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

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

createModifier

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

createModifiersFromModifierFlags

abstract fun createModifiersFromModifierFlags(flags: ModifierFlags): ReadonlyArray<Modifier>?

createModuleBlock

abstract fun createModuleBlock(statements: ReadonlyArray<Statement>): ModuleBlock

createModuleDeclaration

abstract fun createModuleDeclaration(modifiers: ReadonlyArray<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: ReadonlyArray<ExportSpecifier>): NamedExports

createNamedImports

abstract fun createNamedImports(elements: ReadonlyArray<ImportSpecifier>): NamedImports

createNamedTupleMember

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

createNamespaceExport

abstract fun createNamespaceExport(name: Identifier): 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: ReadonlyArray<TypeNode>?, argumentsArray: ReadonlyArray<Expression>?): NewExpression

createNodeArray

abstract fun <T : Node> createNodeArray(elements: ReadonlyArray<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

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: ReadonlyArray<BindingElement>): ObjectBindingPattern

createObjectLiteralExpression

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

createOmittedExpression

abstract fun createOmittedExpression(): OmittedExpression

createOptionalTypeNode

abstract fun createOptionalTypeNode(type: TypeNode): OptionalTypeNode

createParameterDeclaration

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

abstract fun createParameterDeclaration(modifiers: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, name: String, questionOrExclamationToken: ExclamationToken?, type: TypeNode?, initializer: Expression?): PropertyDeclaration

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

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

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

createPropertySignature

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

abstract fun createPropertySignature(modifiers: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, name: String, parameters: ReadonlyArray<ParameterDeclaration>, body: Block?): SetAccessorDeclaration

abstract fun createSetAccessorDeclaration(modifiers: ReadonlyArray<ModifierLike>?, name: PropertyName, parameters: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<TypeNode>?, template: TemplateLiteral): TaggedTemplateExpression

createTemplateExpression

abstract fun createTemplateExpression(head: TemplateHead, templateSpans: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<NodeFactoryCreateTupleTypeNodeElementsItem>): TupleTypeNode

createTypeAliasDeclaration

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

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

createTypeAssertion

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

createTypeLiteralNode

abstract fun createTypeLiteralNode(members: ReadonlyArray<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: ReadonlyArray<Modifier>?, name: String, constraint: TypeNode = definedExternally, defaultType: TypeNode = definedExternally): TypeParameterDeclaration

abstract fun createTypeParameterDeclaration(modifiers: ReadonlyArray<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: ReadonlyArray<TypeNode> = definedExternally): TypeQueryNode

createTypeReferenceNode

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

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

createUnionTypeNode

abstract fun createUnionTypeNode(types: ReadonlyArray<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: ReadonlyArray<VariableDeclaration>, flags: NodeFlags = definedExternally): VariableDeclarationList

createVariableStatement

abstract fun createVariableStatement(modifiers: ReadonlyArray<ModifierLike>?, declarationList: ReadonlyArray<VariableDeclaration>): VariableStatement

abstract fun createVariableStatement(modifiers: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<ArrayBindingElement>): ArrayBindingPattern

updateArrayLiteralExpression

abstract fun updateArrayLiteralExpression(node: ArrayLiteralExpression, elements: ReadonlyArray<Expression>): ArrayLiteralExpression

updateArrayTypeNode

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

updateArrowFunction

abstract fun updateArrowFunction(node: ArrowFunction, modifiers: ReadonlyArray<Modifier>?, typeParameters: ReadonlyArray<TypeParameterDeclaration>?, parameters: ReadonlyArray<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: ReadonlyArray<Statement>): Block

updateBreakStatement

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

updateBundle

abstract fun updateBundle(node: Bundle, sourceFiles: ReadonlyArray<SourceFile>): Bundle

abstract fun updateBundle(node: Bundle, sourceFiles: ReadonlyArray<SourceFile>, prepends: ReadonlyArray<NodeFactoryUpdateBundlePrependsItem> = definedExternally): Bundle

updateCallChain

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

updateCallExpression

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

updateCallSignature

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

updateCaseBlock

abstract fun updateCaseBlock(node: CaseBlock, clauses: ReadonlyArray<CaseOrDefaultClause>): CaseBlock

updateCaseClause

abstract fun updateCaseClause(node: CaseClause, expression: Expression, statements: ReadonlyArray<Statement>): CaseClause

updateCatchClause

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

updateClassDeclaration

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

updateClassExpression

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

updateClassStaticBlockDeclaration

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

updateCommaListExpression

abstract fun updateCommaListExpression(node: CommaListExpression, elements: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, parameters: ReadonlyArray<ParameterDeclaration>, body: Block?): ConstructorDeclaration

updateConstructorTypeNode

abstract fun updateConstructorTypeNode(node: ConstructorTypeNode, modifiers: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, name: Identifier, members: ReadonlyArray<EnumMember>): EnumDeclaration

updateEnumMember

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

updateExportAssignment

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

updateExportDeclaration

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

updateExportSpecifier

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

updateExpressionStatement

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

updateExpressionWithTypeArguments

abstract fun updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, expression: Expression, typeArguments: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, asteriskToken: AsteriskToken?, name: Identifier?, typeParameters: ReadonlyArray<TypeParameterDeclaration>?, parameters: ReadonlyArray<ParameterDeclaration>, type: TypeNode?, body: Block?): FunctionDeclaration

updateFunctionExpression

abstract fun updateFunctionExpression(node: FunctionExpression, modifiers: ReadonlyArray<Modifier>?, asteriskToken: AsteriskToken?, name: Identifier?, typeParameters: ReadonlyArray<TypeParameterDeclaration>?, parameters: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, name: PropertyName, parameters: ReadonlyArray<ParameterDeclaration>, type: TypeNode?, body: Block?): GetAccessorDeclaration

updateHeritageClause

abstract fun updateHeritageClause(node: HeritageClause, types: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, importClause: ImportClause?, moduleSpecifier: Expression, attributes: ImportAttributes?): ImportDeclaration

updateImportEqualsDeclaration

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

updateImportSpecifier

abstract fun updateImportSpecifier(node: ImportSpecifier, isTypeOnly: Boolean, propertyName: Identifier?, 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: ReadonlyArray<TypeNode>?, isTypeOf: Boolean = definedExternally): ImportTypeNode

updateIndexedAccessTypeNode

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

updateIndexSignature

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

updateInferTypeNode

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

updateInterfaceDeclaration

abstract fun updateInterfaceDeclaration(node: InterfaceDeclaration, modifiers: ReadonlyArray<ModifierLike>?, name: Identifier, typeParameters: ReadonlyArray<TypeParameterDeclaration>?, heritageClauses: ReadonlyArray<HeritageClause>?, members: ReadonlyArray<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: ReadonlyArray<JSDocTag>?): JSDoc

abstract fun updateJSDocComment(node: JSDoc, comment: NodeArray<JSDocComment>?, tags: ReadonlyArray<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: ReadonlyArray<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

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: ReadonlyArray<JSDocTemplateTag>?, parameters: ReadonlyArray<JSDocParameterTag>, type: JSDocReturnTag?): JSDocSignature

updateJSDocTemplateTag

abstract fun updateJSDocTemplateTag(node: JSDocTemplateTag, tagName: Identifier?, constraint: JSDocTypeExpression?, typeParameters: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<JsxAttributeLike>): JsxAttributes

updateJsxClosingElement

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

updateJsxElement

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

updateJsxExpression

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

updateJsxFragment

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

updateJsxNamespacedName

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

updateJsxOpeningElement

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

updateJsxSelfClosingElement

abstract fun updateJsxSelfClosingElement(node: JsxSelfClosingElement, tagName: JsxTagNameExpression, typeArguments: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, asteriskToken: AsteriskToken?, name: PropertyName, questionToken: QuestionToken?, typeParameters: ReadonlyArray<TypeParameterDeclaration>?, parameters: ReadonlyArray<ParameterDeclaration>, type: TypeNode?, body: Block?): MethodDeclaration

updateMethodSignature

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

updateModuleBlock

abstract fun updateModuleBlock(node: ModuleBlock, statements: ReadonlyArray<Statement>): ModuleBlock

updateModuleDeclaration

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

updateNamedExports

abstract fun updateNamedExports(node: NamedExports, elements: ReadonlyArray<ExportSpecifier>): NamedExports

updateNamedImports

abstract fun updateNamedImports(node: NamedImports, elements: ReadonlyArray<ImportSpecifier>): NamedImports

updateNamedTupleMember

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

updateNamespaceExport

abstract fun updateNamespaceExport(node: NamespaceExport, name: Identifier): 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: ReadonlyArray<TypeNode>?, argumentsArray: ReadonlyArray<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: ReadonlyArray<BindingElement>): ObjectBindingPattern

updateObjectLiteralExpression

abstract fun updateObjectLiteralExpression(node: ObjectLiteralExpression, properties: ReadonlyArray<ObjectLiteralElementLike>): ObjectLiteralExpression

updateOptionalTypeNode

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

updateParameterDeclaration

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

abstract fun updateParameterDeclaration(node: ParameterDeclaration, modifiers: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, name: String, questionOrExclamationToken: ExclamationToken?, type: TypeNode?, initializer: Expression?): PropertyDeclaration

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

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

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

updatePropertySignature

abstract fun updatePropertySignature(node: PropertySignature, modifiers: ReadonlyArray<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: ReadonlyArray<ModifierLike>?, name: PropertyName, parameters: ReadonlyArray<ParameterDeclaration>, body: Block?): SetAccessorDeclaration

updateShorthandPropertyAssignment

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

updateSourceFile

abstract fun updateSourceFile(node: SourceFile, statements: ReadonlyArray<Statement>, isDeclarationFile: Boolean = definedExternally, referencedFiles: ReadonlyArray<FileReference> = definedExternally, typeReferences: ReadonlyArray<FileReference> = definedExternally, hasNoDefaultLib: Boolean = definedExternally, libReferences: ReadonlyArray<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: ReadonlyArray<TypeNode>?, template: TemplateLiteral): TaggedTemplateExpression

updateTemplateExpression

abstract fun updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: ReadonlyArray<TemplateSpan>): TemplateExpression

updateTemplateLiteralType

abstract fun updateTemplateLiteralType(node: TemplateLiteralTypeNode, head: TemplateHead, templateSpans: ReadonlyArray<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: ReadonlyArray<NodeFactoryUpdateTupleTypeNodeElementsItem>): TupleTypeNode

updateTypeAliasDeclaration

abstract fun updateTypeAliasDeclaration(node: TypeAliasDeclaration, modifiers: ReadonlyArray<ModifierLike>?, name: Identifier, typeParameters: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<VariableDeclaration>): VariableDeclarationList

updateVariableStatement

abstract fun updateVariableStatement(node: VariableStatement, modifiers: ReadonlyArray<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