kotlin-typescript/typescript/NodeFactory

NodeFactory

Functions

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

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

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

createArrayTypeNode

abstract external fun createArrayTypeNode(elementType: TypeNode): ArrayTypeNode

createArrowFunction

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

createAsExpression

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

createAssertClause

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

createAssertEntry

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

createAssignment

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

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

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

createAwaitExpression

abstract external fun createAwaitExpression(expression: Expression): AwaitExpression

createBigIntLiteral

abstract external fun createBigIntLiteral(value: String): BigIntLiteral

abstract external fun createBigIntLiteral(value: PseudoBigInt): BigIntLiteral

createBinaryExpression

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

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

createBindingElement

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

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

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

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

createBitwiseAnd

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

createBitwiseNot

abstract external fun createBitwiseNot(operand: Expression): PrefixUnaryExpression

createBitwiseOr

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

createBitwiseXor

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

createBlock

abstract external fun createBlock(statements: ReadonlyArray<Statement>, multiLine: Boolean = definedExternally): Block

createBreakStatement

abstract external fun createBreakStatement(): BreakStatement

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

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

createBundle

abstract external fun createBundle(sourceFiles: ReadonlyArray<SourceFile>): Bundle

createCallChain

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

createCallExpression

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

createCallSignature

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

createCaseBlock

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

createCaseClause

abstract external fun createCaseClause(expression: Expression, statements: ReadonlyArray<Statement>): CaseClause

createCatchClause

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

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

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

createClassDeclaration

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

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

createClassExpression

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

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

createClassStaticBlockDeclaration

abstract external fun createClassStaticBlockDeclaration(body: Block): ClassStaticBlockDeclaration

createComma

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

createCommaListExpression

abstract external fun createCommaListExpression(elements: ReadonlyArray<Expression>): CommaListExpression

createComputedPropertyName

abstract external fun createComputedPropertyName(expression: Expression): ComputedPropertyName

createConditionalExpression

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

createConditionalTypeNode

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

createConstructorDeclaration

abstract external fun createConstructorDeclaration(modifiers: ReadonlyArray<ModifierLike>?, parameters: ReadonlyArray<ParameterDeclaration>, body: Block?): ConstructorDeclaration

createConstructorTypeNode

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

createConstructSignature

abstract external fun createConstructSignature(typeParameters: ReadonlyArray<TypeParameterDeclaration>?, parameters: ReadonlyArray<ParameterDeclaration>, type: TypeNode?): ConstructSignatureDeclaration

createContinueStatement

abstract external fun createContinueStatement(): ContinueStatement

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

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

createDebuggerStatement

abstract external fun createDebuggerStatement(): DebuggerStatement

createDecorator

abstract external fun createDecorator(expression: Expression): Decorator

createDefaultClause

abstract external fun createDefaultClause(statements: ReadonlyArray<Statement>): DefaultClause

createDeleteExpression

abstract external fun createDeleteExpression(expression: Expression): DeleteExpression

createDivide

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

createDoStatement

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

createElementAccessChain

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

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

createElementAccessExpression

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

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

createEmptyStatement

abstract external fun createEmptyStatement(): EmptyStatement

createEnumDeclaration

abstract external fun createEnumDeclaration(modifiers: ReadonlyArray<ModifierLike>?, name: String, members: ReadonlyArray<EnumMember>): EnumDeclaration

abstract external fun createEnumDeclaration(modifiers: ReadonlyArray<ModifierLike>?, name: Identifier, members: ReadonlyArray<EnumMember>): EnumDeclaration

createEnumMember

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

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

createEquality

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

createExponent

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

createExportAssignment

abstract external fun createExportAssignment(modifiers: ReadonlyArray<ModifierLike>?, isExportEquals: Boolean?, expression: Expression): ExportAssignment

createExportDeclaration

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

createExportDefault

abstract external fun createExportDefault(expression: Expression): ExportAssignment

createExportSpecifier

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

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

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

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

createExpressionStatement

abstract external fun createExpressionStatement(expression: Expression): ExpressionStatement

createExpressionWithTypeArguments

abstract external fun createExpressionWithTypeArguments(expression: Expression, typeArguments: ReadonlyArray<TypeNode>?): ExpressionWithTypeArguments

createExternalModuleExport

abstract external fun createExternalModuleExport(exportName: Identifier): ExportDeclaration

createExternalModuleReference

abstract external fun createExternalModuleReference(expression: Expression): ExternalModuleReference

createFalse

abstract external fun createFalse(): FalseLiteral

createForInStatement

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

createForOfStatement

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

createForStatement

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

createFunctionDeclaration

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

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

createFunctionExpression

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

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

createFunctionTypeNode

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

createGetAccessorDeclaration

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

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

createGreaterThan

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

createGreaterThanEquals

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

createHeritageClause

abstract external fun createHeritageClause(token: NodeFactoryCreateHeritageClauseToken, types: ReadonlyArray<ExpressionWithTypeArguments>): HeritageClause

createIdentifier

abstract external fun createIdentifier(text: String): Identifier

createIfStatement

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

createImmediatelyInvokedArrowFunction

abstract external fun createImmediatelyInvokedArrowFunction(statements: ReadonlyArray<Statement>): ImmediatelyInvokedArrowFunction

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

createImmediatelyInvokedFunctionExpression

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

abstract external fun createImmediatelyInvokedFunctionExpression(statements: ReadonlyArray<Statement>, param: ParameterDeclaration, paramValue: Expression): CallExpression

createImportAttribute

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

createImportAttributes

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

createImportClause

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

abstract external fun createImportClause(phaseModifier: ImportPhaseModifierSyntaxKind?, name: Identifier?, namedBindings: NamedImportBindings?): ImportClause

createImportDeclaration

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

createImportEqualsDeclaration

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

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

createImportSpecifier

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

createImportTypeAssertionContainer

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

createImportTypeNode

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

createIndexedAccessTypeNode

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

createIndexSignature

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

createInequality

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

createInferTypeNode

abstract external fun createInferTypeNode(typeParameter: TypeParameterDeclaration): InferTypeNode

createInterfaceDeclaration

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

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

createIntersectionTypeNode

abstract external fun createIntersectionTypeNode(types: ReadonlyArray<TypeNode>): IntersectionTypeNode

createJSDocAllType

abstract external fun createJSDocAllType(): JSDocAllType

createJSDocAugmentsTag

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

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

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

createJSDocAuthorTag

abstract external fun createJSDocAuthorTag(tagName: Identifier?): JSDocAuthorTag

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

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

createJSDocCallbackTag

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

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

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

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

createJSDocClassTag

abstract external fun createJSDocClassTag(tagName: Identifier?): JSDocClassTag

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

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

createJSDocComment

abstract external fun createJSDocComment(): JSDoc

abstract external fun createJSDocComment(comment: String? = definedExternally, tags: ReadonlyArray<JSDocTag>? = definedExternally): JSDoc

abstract external fun createJSDocComment(comment: NodeArray<JSDocComment>? = definedExternally, tags: ReadonlyArray<JSDocTag>? = definedExternally): JSDoc

createJSDocDeprecatedTag

abstract external fun createJSDocDeprecatedTag(tagName: Identifier?): JSDocDeprecatedTag

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

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

createJSDocEnumTag

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

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

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

createJSDocFunctionType

abstract external fun createJSDocFunctionType(parameters: ReadonlyArray<ParameterDeclaration>, type: TypeNode?): JSDocFunctionType

createJSDocImplementsTag

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

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

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

createJSDocImportTag

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

createJSDocLink

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

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

createJSDocLinkCode

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

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

createJSDocLinkPlain

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

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

createJSDocMemberName

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

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

createJSDocNamepathType

abstract external fun createJSDocNamepathType(type: TypeNode): JSDocNamepathType

createJSDocNameReference

abstract external fun createJSDocNameReference(name: EntityName): JSDocNameReference

abstract external fun createJSDocNameReference(name: JSDocMemberName): JSDocNameReference

createJSDocNonNullableType

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

createJSDocNullableType

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

createJSDocOptionalType

abstract external fun createJSDocOptionalType(type: TypeNode): JSDocOptionalType

createJSDocOverloadTag

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

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

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

createJSDocOverrideTag

abstract external fun createJSDocOverrideTag(tagName: Identifier?): JSDocOverrideTag

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

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

createJSDocParameterTag

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

createJSDocPrivateTag

abstract external fun createJSDocPrivateTag(tagName: Identifier?): JSDocPrivateTag

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

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

createJSDocPropertyTag

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

createJSDocProtectedTag

abstract external fun createJSDocProtectedTag(tagName: Identifier?): JSDocProtectedTag

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

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

createJSDocPublicTag

abstract external fun createJSDocPublicTag(tagName: Identifier?): JSDocPublicTag

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

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

createJSDocReadonlyTag

abstract external fun createJSDocReadonlyTag(tagName: Identifier?): JSDocReadonlyTag

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

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

createJSDocReturnTag

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

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

createJSDocSatisfiesTag

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

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

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

createJSDocSeeTag

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

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

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

createJSDocSignature

abstract external fun createJSDocSignature(typeParameters: ReadonlyArray<JSDocTemplateTag>?, parameters: ReadonlyArray<JSDocParameterTag>, type: JSDocReturnTag = definedExternally): JSDocSignature

createJSDocTemplateTag

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

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

createJSDocText

abstract external fun createJSDocText(text: String): JSDocText

createJSDocThisTag

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

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

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

createJSDocThrowsTag

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

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

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

createJSDocTypedefTag

abstract external fun createJSDocTypedefTag(tagName: Identifier?): JSDocTypedefTag

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

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

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

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

createJSDocTypeExpression

abstract external fun createJSDocTypeExpression(type: TypeNode): JSDocTypeExpression

createJSDocTypeLiteral

abstract external fun createJSDocTypeLiteral(jsDocPropertyTags: ReadonlyArray<JSDocPropertyLikeTag> = definedExternally, isArrayType: Boolean = definedExternally): JSDocTypeLiteral

createJSDocTypeTag

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

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

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

createJSDocUnknownTag

abstract external fun createJSDocUnknownTag(tagName: Identifier): JSDocUnknownTag

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

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

createJSDocUnknownType

abstract external fun createJSDocUnknownType(): JSDocUnknownType

createJSDocVariadicType

abstract external fun createJSDocVariadicType(type: TypeNode): JSDocVariadicType

createJsxAttribute

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

createJsxAttributes

abstract external fun createJsxAttributes(properties: ReadonlyArray<JsxAttributeLike>): JsxAttributes

createJsxClosingElement

abstract external fun createJsxClosingElement(tagName: JsxTagNameExpression): JsxClosingElement

createJsxElement

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

createJsxExpression

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

createJsxFragment

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

createJsxJsxClosingFragment

abstract external fun createJsxJsxClosingFragment(): JsxClosingFragment

createJsxNamespacedName

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

createJsxOpeningElement

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

createJsxOpeningFragment

abstract external fun createJsxOpeningFragment(): JsxOpeningFragment

createJsxSelfClosingElement

abstract external fun createJsxSelfClosingElement(tagName: JsxTagNameExpression, typeArguments: ReadonlyArray<TypeNode>?, attributes: JsxAttributes): JsxSelfClosingElement

createJsxSpreadAttribute

abstract external fun createJsxSpreadAttribute(expression: Expression): JsxSpreadAttribute

createJsxText

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

createKeywordTypeNode

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

createLabeledStatement

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

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

createLeftShift

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

createLessThan

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

createLessThanEquals

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

createLiteralTypeNode

abstract external fun createLiteralTypeNode(literal: NodeFactoryCreateLiteralTypeNodeLiteral): LiteralTypeNode

createLogicalAnd

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

createLogicalNot

abstract external fun createLogicalNot(operand: Expression): PrefixUnaryExpression

createLogicalOr

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

createLoopVariable

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

Create a unique temporary variable for use in a loop.

createMappedTypeNode

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

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

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

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

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

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

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

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

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

createMetaProperty

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

createMethodDeclaration

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

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

createMethodSignature

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

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

createModifier

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

createModifiersFromModifierFlags

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

createModuleBlock

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

createModuleDeclaration

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

createModulo

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

createMultiply

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

createNamedExports

abstract external fun createNamedExports(elements: ReadonlyArray<ExportSpecifier>): NamedExports

createNamedImports

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

createNamedTupleMember

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

createNamespaceExport

abstract external fun createNamespaceExport(name: ModuleExportName): NamespaceExport

createNamespaceExportDeclaration

abstract external fun createNamespaceExportDeclaration(name: String): NamespaceExportDeclaration

abstract external fun createNamespaceExportDeclaration(name: Identifier): NamespaceExportDeclaration

createNamespaceImport

abstract external fun createNamespaceImport(name: Identifier): NamespaceImport

createNewExpression

abstract external fun createNewExpression(expression: Expression, typeArguments: ReadonlyArray<TypeNode>?, argumentsArray: ReadonlyArray<Expression>?): NewExpression

createNodeArray

abstract external fun <T : Node> createNodeArray(elements: ReadonlyArray<T> = definedExternally, hasTrailingComma: Boolean = definedExternally): NodeArray<T>

createNonNullChain

abstract external fun createNonNullChain(expression: Expression): NonNullChain

createNonNullExpression

abstract external fun createNonNullExpression(expression: Expression): NonNullExpression

createNoSubstitutionTemplateLiteral

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

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

createNotEmittedStatement

abstract external fun createNotEmittedStatement(original: Node): NotEmittedStatement

createNotEmittedTypeElement

abstract external fun createNotEmittedTypeElement(): NotEmittedTypeElement

createNull

abstract external fun createNull(): NullLiteral

createNumericLiteral

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

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

createObjectBindingPattern

abstract external fun createObjectBindingPattern(elements: ReadonlyArray<BindingElement>): ObjectBindingPattern

createObjectLiteralExpression

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

createOmittedExpression

abstract external fun createOmittedExpression(): OmittedExpression

createOptionalTypeNode

abstract external fun createOptionalTypeNode(type: TypeNode): OptionalTypeNode

createParameterDeclaration

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

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

createParenthesizedExpression

abstract external fun createParenthesizedExpression(expression: Expression): ParenthesizedExpression

createParenthesizedType

abstract external fun createParenthesizedType(type: TypeNode): ParenthesizedTypeNode

createPartiallyEmittedExpression

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

createPostfixDecrement

abstract external fun createPostfixDecrement(operand: Expression): PostfixUnaryExpression

createPostfixIncrement

abstract external fun createPostfixIncrement(operand: Expression): PostfixUnaryExpression

createPostfixUnaryExpression

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

createPrefixDecrement

abstract external fun createPrefixDecrement(operand: Expression): PrefixUnaryExpression

createPrefixIncrement

abstract external fun createPrefixIncrement(operand: Expression): PrefixUnaryExpression

createPrefixMinus

abstract external fun createPrefixMinus(operand: Expression): PrefixUnaryExpression

createPrefixPlus

abstract external fun createPrefixPlus(operand: Expression): PrefixUnaryExpression

createPrefixUnaryExpression

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

createPrivateIdentifier

abstract external fun createPrivateIdentifier(text: String): PrivateIdentifier

createPropertyAccessChain

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

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

createPropertyAccessExpression

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

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

createPropertyAssignment

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

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

createPropertyDeclaration

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

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

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

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

createPropertySignature

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

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

createQualifiedName

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

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

createRegularExpressionLiteral

abstract external fun createRegularExpressionLiteral(text: String): RegularExpressionLiteral

createRestTypeNode

abstract external fun createRestTypeNode(type: TypeNode): RestTypeNode

createReturnStatement

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

createRightShift

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

createSatisfiesExpression

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

createSemicolonClassElement

abstract external fun createSemicolonClassElement(): SemicolonClassElement

createSetAccessorDeclaration

abstract external fun createSetAccessorDeclaration(modifiers: ReadonlyArray<ModifierLike>?, name: String, parameters: ReadonlyArray<ParameterDeclaration>, body: Block?): SetAccessorDeclaration

abstract external fun createSetAccessorDeclaration(modifiers: ReadonlyArray<ModifierLike>?, name: PropertyName, parameters: ReadonlyArray<ParameterDeclaration>, body: Block?): SetAccessorDeclaration

createShorthandPropertyAssignment

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

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

createSourceFile

abstract external fun createSourceFile(statements: ReadonlyArray<Statement>, endOfFileToken: EndOfFileToken, flags: NodeFlags): SourceFile

createSpreadAssignment

abstract external fun createSpreadAssignment(expression: Expression): SpreadAssignment

createSpreadElement

abstract external fun createSpreadElement(expression: Expression): SpreadElement

createStrictEquality

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

createStrictInequality

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

createStringLiteral

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

createStringLiteralFromNode

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

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

createSubtract

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

createSuper

abstract external fun createSuper(): SuperExpression

createSwitchStatement

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

createTaggedTemplateExpression

abstract external fun createTaggedTemplateExpression(tag: Expression, typeArguments: ReadonlyArray<TypeNode>?, template: TemplateLiteral): TaggedTemplateExpression

createTemplateExpression

abstract external fun createTemplateExpression(head: TemplateHead, templateSpans: ReadonlyArray<TemplateSpan>): TemplateExpression

createTemplateHead

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

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

createTemplateLiteralType

abstract external fun createTemplateLiteralType(head: TemplateHead, templateSpans: ReadonlyArray<TemplateLiteralTypeSpan>): TemplateLiteralTypeNode

createTemplateLiteralTypeSpan

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

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

createTemplateMiddle

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

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

createTemplateSpan

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

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

createTemplateTail

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

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

createTempVariable

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

Create a unique temporary variable.

createThis

abstract external fun createThis(): ThisExpression

createThisTypeNode

abstract external fun createThisTypeNode(): ThisTypeNode

createThrowStatement

abstract external fun createThrowStatement(expression: Expression): ThrowStatement

createToken

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

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

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

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

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

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

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

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

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

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

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

createTrue

abstract external fun createTrue(): TrueLiteral

createTryStatement

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

createTupleTypeNode

abstract external fun createTupleTypeNode(elements: ReadonlyArray<NodeFactoryCreateTupleTypeNodeElementsItem>): TupleTypeNode

createTypeAliasDeclaration

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

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

createTypeAssertion

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

createTypeLiteralNode

abstract external fun createTypeLiteralNode(members: ReadonlyArray<TypeElement>?): TypeLiteralNode

createTypeOfExpression

abstract external fun createTypeOfExpression(expression: Expression): TypeOfExpression

createTypeOperatorNode

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

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

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

createTypeParameterDeclaration

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

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

createTypePredicateNode

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

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

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

createTypeQueryNode

abstract external fun createTypeQueryNode(exprName: EntityName, typeArguments: ReadonlyArray<TypeNode> = definedExternally): TypeQueryNode

createTypeReferenceNode

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

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

createUnionTypeNode

abstract external fun createUnionTypeNode(types: ReadonlyArray<TypeNode>): UnionTypeNode

createUniqueName

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

Create a unique name based on the supplied text.

createUniquePrivateName

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

createUnsignedRightShift

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

createVariableDeclaration

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

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

createVariableDeclarationList

abstract external fun createVariableDeclarationList(declarations: ReadonlyArray<VariableDeclaration>, flags: NodeFlags = definedExternally): VariableDeclarationList

createVariableStatement

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

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

createVoidExpression

abstract external fun createVoidExpression(expression: Expression): VoidExpression

createVoidZero

abstract external fun createVoidZero(): VoidExpression

createWhileStatement

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

createWithStatement

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

createYieldExpression

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

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

getGeneratedNameForNode

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

Create a unique name generated for a node.

getGeneratedPrivateNameForNode

abstract external fun getGeneratedPrivateNameForNode(node: Node): PrivateIdentifier

replaceDecoratorsAndModifiers

abstract external 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 external fun <T : HasModifiers> replaceModifiers(node: T, modifiers: ReadonlyArray<Modifier>?): T

abstract external 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 external 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 external fun restoreOuterExpressions(outerExpression: Expression?, innerExpression: Expression, kinds: OuterExpressionKinds = definedExternally): Expression

updateArrayBindingPattern

abstract external fun updateArrayBindingPattern(node: ArrayBindingPattern, elements: ReadonlyArray<ArrayBindingElement>): ArrayBindingPattern

updateArrayLiteralExpression

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

updateArrayTypeNode

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

updateArrowFunction

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

updateAsExpression

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

updateAssertClause

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

updateAssertEntry

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

updateAwaitExpression

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

updateBinaryExpression

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

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

updateBindingElement

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

updateBlock

abstract external fun updateBlock(node: Block, statements: ReadonlyArray<Statement>): Block

updateBreakStatement

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

updateBundle

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

updateCallChain

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

updateCallExpression

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

updateCallSignature

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

updateCaseBlock

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

updateCaseClause

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

updateCatchClause

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

updateClassDeclaration

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

updateClassExpression

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

updateClassStaticBlockDeclaration

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

updateCommaListExpression

abstract external fun updateCommaListExpression(node: CommaListExpression, elements: ReadonlyArray<Expression>): CommaListExpression

updateComputedPropertyName

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

updateConditionalExpression

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

updateConditionalTypeNode

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

updateConstructorDeclaration

abstract external fun updateConstructorDeclaration(node: ConstructorDeclaration, modifiers: ReadonlyArray<ModifierLike>?, parameters: ReadonlyArray<ParameterDeclaration>, body: Block?): ConstructorDeclaration

updateConstructorTypeNode

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

updateConstructSignature

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

updateContinueStatement

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

updateDecorator

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

updateDefaultClause

abstract external fun updateDefaultClause(node: DefaultClause, statements: ReadonlyArray<Statement>): DefaultClause

updateDeleteExpression

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

updateDoStatement

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

updateElementAccessChain

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

updateElementAccessExpression

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

updateEnumDeclaration

abstract external fun updateEnumDeclaration(node: EnumDeclaration, modifiers: ReadonlyArray<ModifierLike>?, name: Identifier, members: ReadonlyArray<EnumMember>): EnumDeclaration

updateEnumMember

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

updateExportAssignment

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

updateExportDeclaration

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

updateExportSpecifier

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

updateExpressionStatement

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

updateExpressionWithTypeArguments

abstract external fun updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, expression: Expression, typeArguments: ReadonlyArray<TypeNode>?): ExpressionWithTypeArguments

updateExternalModuleReference

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

updateForInStatement

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

updateForOfStatement

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

updateForStatement

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

updateFunctionDeclaration

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

updateFunctionExpression

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

updateFunctionTypeNode

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

updateGetAccessorDeclaration

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

updateHeritageClause

abstract external fun updateHeritageClause(node: HeritageClause, types: ReadonlyArray<ExpressionWithTypeArguments>): HeritageClause

updateIfStatement

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

updateImportAttribute

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

updateImportAttributes

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

updateImportClause

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

abstract external fun updateImportClause(node: ImportClause, phaseModifier: ImportPhaseModifierSyntaxKind?, name: Identifier?, namedBindings: NamedImportBindings?): ImportClause

updateImportDeclaration

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

updateImportEqualsDeclaration

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

updateImportSpecifier

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

updateImportTypeAssertionContainer

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

updateImportTypeNode

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

updateIndexedAccessTypeNode

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

updateIndexSignature

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

updateInferTypeNode

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

updateInterfaceDeclaration

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

updateIntersectionTypeNode

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

updateJSDocAugmentsTag

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

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

updateJSDocAuthorTag

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

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

updateJSDocCallbackTag

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

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

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

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

updateJSDocClassTag

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

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

updateJSDocComment

abstract external fun updateJSDocComment(node: JSDoc, comment: String?, tags: ReadonlyArray<JSDocTag>?): JSDoc

abstract external fun updateJSDocComment(node: JSDoc, comment: NodeArray<JSDocComment>?, tags: ReadonlyArray<JSDocTag>?): JSDoc

updateJSDocDeprecatedTag

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

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

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

updateJSDocEnumTag

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

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

updateJSDocFunctionType

abstract external fun updateJSDocFunctionType(node: JSDocFunctionType, parameters: ReadonlyArray<ParameterDeclaration>, type: TypeNode?): JSDocFunctionType

updateJSDocImplementsTag

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

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

updateJSDocImportTag

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

updateJSDocLink

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

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

updateJSDocLinkCode

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

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

updateJSDocLinkPlain

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

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

updateJSDocMemberName

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

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

updateJSDocNamepathType

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

updateJSDocNameReference

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

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

updateJSDocNonNullableType

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

updateJSDocNullableType

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

updateJSDocOptionalType

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

updateJSDocOverloadTag

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

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

updateJSDocOverrideTag

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

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

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

updateJSDocParameterTag

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

updateJSDocPrivateTag

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

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

updateJSDocPropertyTag

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

updateJSDocProtectedTag

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

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

updateJSDocPublicTag

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

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

updateJSDocReadonlyTag

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

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

updateJSDocReturnTag

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

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

updateJSDocSatisfiesTag

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

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

updateJSDocSeeTag

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

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

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

updateJSDocSignature

abstract external fun updateJSDocSignature(node: JSDocSignature, typeParameters: ReadonlyArray<JSDocTemplateTag>?, parameters: ReadonlyArray<JSDocParameterTag>, type: JSDocReturnTag?): JSDocSignature

updateJSDocTemplateTag

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

updateJSDocText

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

updateJSDocThisTag

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

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

updateJSDocThrowsTag

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

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

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

updateJSDocTypedefTag

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

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

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

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

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

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

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

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

updateJSDocTypeExpression

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

updateJSDocTypeLiteral

abstract external fun updateJSDocTypeLiteral(node: JSDocTypeLiteral, jsDocPropertyTags: ReadonlyArray<JSDocPropertyLikeTag>?, isArrayType: Boolean?): JSDocTypeLiteral

updateJSDocTypeTag

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

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

updateJSDocUnknownTag

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

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

updateJSDocVariadicType

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

updateJsxAttribute

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

updateJsxAttributes

abstract external fun updateJsxAttributes(node: JsxAttributes, properties: ReadonlyArray<JsxAttributeLike>): JsxAttributes

updateJsxClosingElement

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

updateJsxElement

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

updateJsxExpression

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

updateJsxFragment

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

updateJsxNamespacedName

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

updateJsxOpeningElement

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

updateJsxSelfClosingElement

abstract external fun updateJsxSelfClosingElement(node: JsxSelfClosingElement, tagName: JsxTagNameExpression, typeArguments: ReadonlyArray<TypeNode>?, attributes: JsxAttributes): JsxSelfClosingElement

updateJsxSpreadAttribute

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

updateJsxText

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

updateLabeledStatement

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

updateLiteralTypeNode

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

updateMappedTypeNode

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

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

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

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

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

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

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

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

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

updateMetaProperty

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

updateMethodDeclaration

abstract external 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 external fun updateMethodSignature(node: MethodSignature, modifiers: ReadonlyArray<Modifier>?, name: PropertyName, questionToken: QuestionToken?, typeParameters: NodeArray<TypeParameterDeclaration>?, parameters: NodeArray<ParameterDeclaration>, type: TypeNode?): MethodSignature

updateModuleBlock

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

updateModuleDeclaration

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

updateNamedExports

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

updateNamedImports

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

updateNamedTupleMember

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

updateNamespaceExport

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

updateNamespaceExportDeclaration

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

updateNamespaceImport

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

updateNewExpression

abstract external fun updateNewExpression(node: NewExpression, expression: Expression, typeArguments: ReadonlyArray<TypeNode>?, argumentsArray: ReadonlyArray<Expression>?): NewExpression

updateNonNullChain

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

updateNonNullExpression

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

updateObjectBindingPattern

abstract external fun updateObjectBindingPattern(node: ObjectBindingPattern, elements: ReadonlyArray<BindingElement>): ObjectBindingPattern

updateObjectLiteralExpression

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

updateOptionalTypeNode

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

updateParameterDeclaration

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

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

updateParenthesizedExpression

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

updateParenthesizedType

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

updatePartiallyEmittedExpression

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

updatePostfixUnaryExpression

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

updatePrefixUnaryExpression

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

updatePropertyAccessChain

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

updatePropertyAccessExpression

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

updatePropertyAssignment

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

updatePropertyDeclaration

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

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

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

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

updatePropertySignature

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

updateQualifiedName

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

updateRestTypeNode

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

updateReturnStatement

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

updateSatisfiesExpression

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

updateSetAccessorDeclaration

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

updateShorthandPropertyAssignment

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

updateSourceFile

abstract external 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 external fun updateSpreadAssignment(node: SpreadAssignment, expression: Expression): SpreadAssignment

updateSpreadElement

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

updateSwitchStatement

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

updateTaggedTemplateExpression

abstract external fun updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, typeArguments: ReadonlyArray<TypeNode>?, template: TemplateLiteral): TaggedTemplateExpression

updateTemplateExpression

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

updateTemplateLiteralType

abstract external fun updateTemplateLiteralType(node: TemplateLiteralTypeNode, head: TemplateHead, templateSpans: ReadonlyArray<TemplateLiteralTypeSpan>): TemplateLiteralTypeNode

updateTemplateLiteralTypeSpan

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

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

updateTemplateSpan

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

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

updateThrowStatement

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

updateTryStatement

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

updateTupleTypeNode

abstract external fun updateTupleTypeNode(node: TupleTypeNode, elements: ReadonlyArray<NodeFactoryUpdateTupleTypeNodeElementsItem>): TupleTypeNode

updateTypeAliasDeclaration

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

updateTypeAssertion

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

updateTypeLiteralNode

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

updateTypeOfExpression

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

updateTypeOperatorNode

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

updateTypeParameterDeclaration

abstract external fun updateTypeParameterDeclaration(node: TypeParameterDeclaration, modifiers: ReadonlyArray<Modifier>?, name: Identifier, constraint: TypeNode?, defaultType: TypeNode?): TypeParameterDeclaration

updateTypePredicateNode

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

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

updateTypeQueryNode

abstract external fun updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName, typeArguments: ReadonlyArray<TypeNode> = definedExternally): TypeQueryNode

updateTypeReferenceNode

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

updateUnionTypeNode

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

updateVariableDeclaration

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

updateVariableDeclarationList

abstract external fun updateVariableDeclarationList(node: VariableDeclarationList, declarations: ReadonlyArray<VariableDeclaration>): VariableDeclarationList

updateVariableStatement

abstract external fun updateVariableStatement(node: VariableStatement, modifiers: ReadonlyArray<ModifierLike>?, declarationList: VariableDeclarationList): VariableStatement

updateVoidExpression

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

updateWhileStatement

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

updateWithStatement

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

updateYieldExpression

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