@idlizer/arktscgen 2.1.9-arktscgen-5 → 2.1.9-arktscgen-8

package/build/libarkts-copy/src/generated/peers/SequenceExpression.ts

@@ -37,7 +37,7 @@ import { Expression } from "./Expression"
 
 export class SequenceExpression extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 60)
+        assertValidPeer(pointer, 61)
         super(pointer)
     }
     static createSequenceExpression(sequence_arg: readonly Expression[]): SequenceExpression {

package/build/libarkts-copy/src/generated/peers/SpreadElement.ts

@@ -41,7 +41,7 @@ import { ValidationInfo } from "./ValidationInfo"
 
 export class SpreadElement extends AnnotatedExpression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 163)
+        assertValidPeer(pointer, 165)
         super(pointer)
     }
     static createSpreadElement(nodeType: Es2pandaAstNodeType, argument?: Expression): SpreadElement {

package/build/libarkts-copy/src/generated/peers/StringLiteral.ts

@@ -37,7 +37,7 @@ import { Literal } from "./Literal"
 
 export class StringLiteral extends Literal {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 61)
+        assertValidPeer(pointer, 62)
         super(pointer)
     }
     static create1StringLiteral(str: string): StringLiteral {

package/build/libarkts-copy/src/generated/peers/SuperExpression.ts

@@ -37,7 +37,7 @@ import { Expression } from "./Expression"
 
 export class SuperExpression extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 83)
+        assertValidPeer(pointer, 85)
         super(pointer)
     }
     static createSuperExpression(): SuperExpression {

package/build/libarkts-copy/src/generated/peers/SwitchCaseStatement.ts

@@ -38,7 +38,7 @@ import { Statement } from "./Statement"
 
 export class SwitchCaseStatement extends Statement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 85)
+        assertValidPeer(pointer, 87)
         super(pointer)
     }
     static createSwitchCaseStatement(test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement {

package/build/libarkts-copy/src/generated/peers/SwitchStatement.ts

@@ -39,7 +39,7 @@ import { SwitchCaseStatement } from "./SwitchCaseStatement"
 
 export class SwitchStatement extends Statement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 86)
+        assertValidPeer(pointer, 88)
         super(pointer)
     }
     static createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement {

package/build/libarkts-copy/src/generated/peers/TSAnyKeyword.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSAnyKeyword extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 91)
+        assertValidPeer(pointer, 93)
         super(pointer)
     }
     static createTSAnyKeyword(): TSAnyKeyword {

package/build/libarkts-copy/src/generated/peers/TSArrayType.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSArrayType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 102)
+        assertValidPeer(pointer, 104)
         super(pointer)
     }
     static createTSArrayType(elementType?: TypeNode): TSArrayType {

package/build/libarkts-copy/src/generated/peers/TSAsExpression.ts

@@ -39,7 +39,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSAsExpression extends AnnotatedExpression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 138)
+        assertValidPeer(pointer, 140)
         super(pointer)
     }
     static createTSAsExpression(expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression {

package/build/libarkts-copy/src/generated/peers/TSBigintKeyword.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSBigintKeyword extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 98)
+        assertValidPeer(pointer, 100)
         super(pointer)
     }
     static createTSBigintKeyword(): TSBigintKeyword {

package/build/libarkts-copy/src/generated/peers/TSBooleanKeyword.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSBooleanKeyword extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 93)
+        assertValidPeer(pointer, 95)
         super(pointer)
     }
     static createTSBooleanKeyword(): TSBooleanKeyword {

package/build/libarkts-copy/src/generated/peers/TSClassImplements.ts

@@ -38,7 +38,7 @@ import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 
 export class TSClassImplements extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 139)
+        assertValidPeer(pointer, 141)
         super(pointer)
     }
     static createTSClassImplements(expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements {

package/build/libarkts-copy/src/generated/peers/TSConditionalType.ts

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSConditionalType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 111)
+        assertValidPeer(pointer, 113)
         super(pointer)
     }
     static createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType {

package/build/libarkts-copy/src/generated/peers/TSConstructorType.ts

@@ -40,7 +40,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSConstructorType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 126)
+        assertValidPeer(pointer, 128)
         super(pointer)
     }
     static createTSConstructorType(signature: FunctionSignature | undefined, abstract: boolean): TSConstructorType {

package/build/libarkts-copy/src/generated/peers/TSEnumDeclaration.ts

@@ -36,15 +36,16 @@ import { ClassDefinition } from "./ClassDefinition"
 import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
+import { TypeNode } from "./TypeNode"
 import { TypedStatement } from "./TypedStatement"
 
 export class TSEnumDeclaration extends TypedStatement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 87)
+        assertValidPeer(pointer, 89)
         super(pointer)
     }
-    static createTSEnumDeclaration(key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration {
-        const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._CreateTSEnumDeclaration(global.context, passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare))
+    static create1TSEnumDeclaration(key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean, typeNode?: TypeNode): TSEnumDeclaration {
+        const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._CreateTSEnumDeclaration1(global.context, passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare, passNode(typeNode)))
         result.setChildrenParentPtr()
         return result
     }
@@ -53,6 +54,14 @@ export class TSEnumDeclaration extends TypedStatement {
         result.setChildrenParentPtr()
         return result
     }
+    static update1TSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean, typeNode?: TypeNode): TSEnumDeclaration {
+        const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration1(global.context, passNode(original), passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare, passNode(typeNode)))
+        result.setChildrenParentPtr()
+        return result
+    }
+    get typeNodes(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSEnumDeclarationTypeNodes(global.context, this.peer))
+    }
     get key(): Identifier | undefined {
         return unpackNode(global.generatedEs2panda._TSEnumDeclarationKey(global.context, this.peer))
     }

package/build/libarkts-copy/src/generated/peers/TSEnumMember.ts

@@ -38,7 +38,7 @@ import { Statement } from "./Statement"
 
 export class TSEnumMember extends Statement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 88)
+        assertValidPeer(pointer, 90)
         super(pointer)
     }
     static create1TSEnumMember(key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember {

package/build/libarkts-copy/src/generated/peers/TSExternalModuleReference.ts

@@ -37,7 +37,7 @@ import { Expression } from "./Expression"
 
 export class TSExternalModuleReference extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 89)
+        assertValidPeer(pointer, 91)
         super(pointer)
     }
     static createTSExternalModuleReference(expr?: Expression): TSExternalModuleReference {

package/build/libarkts-copy/src/generated/peers/TSFunctionType.ts

@@ -40,7 +40,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSFunctionType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 125)
+        assertValidPeer(pointer, 127)
         super(pointer)
     }
     static createTSFunctionType(signature?: FunctionSignature): TSFunctionType {

package/build/libarkts-copy/src/generated/peers/TSImportEqualsDeclaration.ts

@@ -39,7 +39,7 @@ import { Statement } from "./Statement"
 
 export class TSImportEqualsDeclaration extends Statement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 124)
+        assertValidPeer(pointer, 126)
         super(pointer)
     }
     static createTSImportEqualsDeclaration(id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration {

package/build/libarkts-copy/src/generated/peers/TSImportType.ts

@@ -39,7 +39,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSImportType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 112)
+        assertValidPeer(pointer, 114)
         super(pointer)
     }
     static createTSImportType(param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType {

package/build/libarkts-copy/src/generated/peers/TSIndexSignature.ts

@@ -40,7 +40,7 @@ import { TypedAstNode } from "./TypedAstNode"
 
 export class TSIndexSignature extends TypedAstNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 136)
+        assertValidPeer(pointer, 138)
         super(pointer)
     }
     static createTSIndexSignature(param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature {

package/build/libarkts-copy/src/generated/peers/TSIndexedAccessType.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSIndexedAccessType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 130)
+        assertValidPeer(pointer, 132)
         super(pointer)
     }
     static createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType {

package/build/libarkts-copy/src/generated/peers/TSInferType.ts

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSInferType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 110)
+        assertValidPeer(pointer, 112)
         super(pointer)
     }
     static createTSInferType(typeParam?: TSTypeParameter): TSInferType {

package/build/libarkts-copy/src/generated/peers/TSInterfaceBody.ts

@@ -37,7 +37,7 @@ import { Expression } from "./Expression"
 
 export class TSInterfaceBody extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 132)
+        assertValidPeer(pointer, 134)
         super(pointer)
     }
     static createTSInterfaceBody(body: readonly AstNode[]): TSInterfaceBody {

package/build/libarkts-copy/src/generated/peers/TSInterfaceDeclaration.ts

@@ -36,6 +36,7 @@ import { AnnotationUsage } from "./AnnotationUsage"
 import { ClassDeclaration } from "./ClassDeclaration"
 import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
+import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
 import { TSInterfaceBody } from "./TSInterfaceBody"
 import { TSInterfaceHeritage } from "./TSInterfaceHeritage"
@@ -44,16 +45,24 @@ import { TypedStatement } from "./TypedStatement"
 
 export class TSInterfaceDeclaration extends TypedStatement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 131)
+        assertValidPeer(pointer, 133)
         super(pointer)
     }
-    static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration {
+    static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean, modifierFlags?: Es2pandaModifierFlags): TSInterfaceDeclaration {
         const result: TSInterfaceDeclaration = new TSInterfaceDeclaration(global.generatedEs2panda._CreateTSInterfaceDeclaration(global.context, passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal))
+        if (modifierFlags)
+        {
+            result.modifierFlags = modifierFlags
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration | undefined, _extends: readonly TSInterfaceHeritage[], id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration {
+    static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration | undefined, _extends: readonly TSInterfaceHeritage[], id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean, modifierFlags?: Es2pandaModifierFlags): TSInterfaceDeclaration {
         const result: TSInterfaceDeclaration = new TSInterfaceDeclaration(global.generatedEs2panda._UpdateTSInterfaceDeclaration(global.context, passNode(original), passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal))
+        if (modifierFlags)
+        {
+            result.modifierFlags = modifierFlags
+        }
         result.setChildrenParentPtr()
         return result
     }

package/build/libarkts-copy/src/generated/peers/TSInterfaceHeritage.ts

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSInterfaceHeritage extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 133)
+        assertValidPeer(pointer, 135)
         super(pointer)
     }
     static createTSInterfaceHeritage(expr?: TypeNode): TSInterfaceHeritage {

package/build/libarkts-copy/src/generated/peers/TSIntersectionType.ts

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSIntersectionType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 113)
+        assertValidPeer(pointer, 115)
         super(pointer)
     }
     static createTSIntersectionType(types: readonly Expression[]): TSIntersectionType {

package/build/libarkts-copy/src/generated/peers/TSLiteralType.ts

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSLiteralType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 109)
+        assertValidPeer(pointer, 111)
         super(pointer)
     }
     static createTSLiteralType(literal?: Expression): TSLiteralType {

package/build/libarkts-copy/src/generated/peers/TSMappedType.ts

@@ -39,7 +39,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSMappedType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 114)
+        assertValidPeer(pointer, 116)
         super(pointer)
     }
     static createTSMappedType(typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType {

package/build/libarkts-copy/src/generated/peers/TSMethodSignature.ts

@@ -40,7 +40,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSMethodSignature extends AstNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 106)
+        assertValidPeer(pointer, 108)
         super(pointer)
     }
     static createTSMethodSignature(key: Expression | undefined, signature: FunctionSignature | undefined, computed: boolean, optional_arg: boolean): TSMethodSignature {

package/build/libarkts-copy/src/generated/peers/TSModuleBlock.ts

@@ -37,7 +37,7 @@ import { Statement } from "./Statement"
 
 export class TSModuleBlock extends Statement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 115)
+        assertValidPeer(pointer, 117)
         super(pointer)
     }
     static createTSModuleBlock(statements: readonly Statement[]): TSModuleBlock {

package/build/libarkts-copy/src/generated/peers/TSModuleDeclaration.ts

@@ -38,7 +38,7 @@ import { Statement } from "./Statement"
 
 export class TSModuleDeclaration extends Statement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 123)
+        assertValidPeer(pointer, 125)
         super(pointer)
     }
     static createTSModuleDeclaration(name: Expression | undefined, body: Statement | undefined, declare: boolean, _global: boolean): TSModuleDeclaration {

package/build/libarkts-copy/src/generated/peers/TSNamedTupleMember.ts

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSNamedTupleMember extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 135)
+        assertValidPeer(pointer, 137)
         super(pointer)
     }
     static createTSNamedTupleMember(label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember {

package/build/libarkts-copy/src/generated/peers/TSNeverKeyword.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSNeverKeyword extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 99)
+        assertValidPeer(pointer, 101)
         super(pointer)
     }
     static createTSNeverKeyword(): TSNeverKeyword {

package/build/libarkts-copy/src/generated/peers/TSNonNullExpression.ts

@@ -37,7 +37,7 @@ import { Expression } from "./Expression"
 
 export class TSNonNullExpression extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 100)
+        assertValidPeer(pointer, 102)
         super(pointer)
     }
     static createTSNonNullExpression(expr?: Expression): TSNonNullExpression {

package/build/libarkts-copy/src/generated/peers/TSNullKeyword.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSNullKeyword extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 101)
+        assertValidPeer(pointer, 103)
         super(pointer)
     }
     static createTSNullKeyword(): TSNullKeyword {

package/build/libarkts-copy/src/generated/peers/TSNumberKeyword.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSNumberKeyword extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 90)
+        assertValidPeer(pointer, 92)
         super(pointer)
     }
     static createTSNumberKeyword(): TSNumberKeyword {

package/build/libarkts-copy/src/generated/peers/TSObjectKeyword.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSObjectKeyword extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 97)
+        assertValidPeer(pointer, 99)
         super(pointer)
     }
     static createTSObjectKeyword(): TSObjectKeyword {

package/build/libarkts-copy/src/generated/peers/TSParameterProperty.ts

@@ -38,7 +38,7 @@ import { Expression } from "./Expression"
 
 export class TSParameterProperty extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 122)
+        assertValidPeer(pointer, 124)
         super(pointer)
     }
     static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty {

package/build/libarkts-copy/src/generated/peers/TSParenthesizedType.ts

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSParenthesizedType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 108)
+        assertValidPeer(pointer, 110)
         super(pointer)
     }
     static createTSParenthesizedType(type?: TypeNode): TSParenthesizedType {

package/build/libarkts-copy/src/generated/peers/TSPropertySignature.ts

@@ -39,7 +39,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSPropertySignature extends AnnotatedAstNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 105)
+        assertValidPeer(pointer, 107)
         super(pointer)
     }
     static createTSPropertySignature(key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature {

package/build/libarkts-copy/src/generated/peers/TSQualifiedName.ts

@@ -38,7 +38,7 @@ import { Identifier } from "./Identifier"
 
 export class TSQualifiedName extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 129)
+        assertValidPeer(pointer, 131)
         super(pointer)
     }
     static createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName {

package/build/libarkts-copy/src/generated/peers/TSSignatureDeclaration.ts

@@ -42,7 +42,7 @@ import { TypedAstNode } from "./TypedAstNode"
 
 export class TSSignatureDeclaration extends TypedAstNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 107)
+        assertValidPeer(pointer, 109)
         super(pointer)
     }
     static createTSSignatureDeclaration(kind: Es2pandaTSSignatureDeclarationKind, signature?: FunctionSignature): TSSignatureDeclaration {

package/build/libarkts-copy/src/generated/peers/TSStringKeyword.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSStringKeyword extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 92)
+        assertValidPeer(pointer, 94)
         super(pointer)
     }
     static createTSStringKeyword(): TSStringKeyword {

package/build/libarkts-copy/src/generated/peers/TSThisType.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSThisType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 116)
+        assertValidPeer(pointer, 118)
         super(pointer)
     }
     static createTSThisType(): TSThisType {

package/build/libarkts-copy/src/generated/peers/TSTupleType.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSTupleType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 134)
+        assertValidPeer(pointer, 136)
         super(pointer)
     }
     static createTSTupleType(elementTypes: readonly TypeNode[]): TSTupleType {

package/build/libarkts-copy/src/generated/peers/TSTypeAliasDeclaration.ts

@@ -36,27 +36,52 @@ import { AnnotatedStatement } from "./AnnotatedStatement"
 import { AnnotationUsage } from "./AnnotationUsage"
 import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
+import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 
 export class TSTypeAliasDeclaration extends AnnotatedStatement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 127)
+        assertValidPeer(pointer, 129)
         super(pointer)
     }
-    static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration {
+    static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
         const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration(global.context, passNode(id), passNode(typeParams), passNode(typeAnnotation)))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
+        if (modifierFlags)
+        {
+            result.modifierFlags = modifierFlags
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration {
+    static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
         const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration(global.context, passNode(original), passNode(id), passNode(typeParams), passNode(typeAnnotation)))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
+        if (modifierFlags)
+        {
+            result.modifierFlags = modifierFlags
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier): TSTypeAliasDeclaration {
+    static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
         const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration1(global.context, passNode(original), passNode(id)))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
+        if (modifierFlags)
+        {
+            result.modifierFlags = modifierFlags
+        }
         result.setChildrenParentPtr()
         return result
     }

package/build/libarkts-copy/src/generated/peers/TSTypeAssertion.ts

@@ -39,7 +39,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSTypeAssertion extends AnnotatedExpression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 140)
+        assertValidPeer(pointer, 142)
         super(pointer)
     }
     static createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion {

package/build/libarkts-copy/src/generated/peers/TSTypeLiteral.ts

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSTypeLiteral extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 104)
+        assertValidPeer(pointer, 106)
         super(pointer)
     }
     static createTSTypeLiteral(members: readonly AstNode[]): TSTypeLiteral {

package/build/libarkts-copy/src/generated/peers/TSTypeOperator.ts

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSTypeOperator extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 117)
+        assertValidPeer(pointer, 119)
         super(pointer)
     }
     static createTSTypeOperator(type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator {

package/build/libarkts-copy/src/generated/peers/TSTypeParameter.ts

@@ -41,7 +41,7 @@ import { TypeNode } from "./TypeNode"
 
 export class TSTypeParameter extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 118)
+        assertValidPeer(pointer, 120)
         super(pointer)
     }
     static create1TSTypeParameter(name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter {