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

package/build/libarkts-copy/src/generated/Es2pandaNativeModule.ts

@@ -28,7 +28,7 @@ import {
     KLong
 } from "@koalaui/interop"
 
-// TODO: this type should be in interop
+// Improve: this type should be in interop
 export type KNativePointerArray = BigUint64Array
 
 export class Es2pandaNativeModule {
@@ -182,12 +182,6 @@ export class Es2pandaNativeModule {
     _ETSFunctionTypeFlagsConst(context: KNativePointer, receiver: KNativePointer): KInt {
         throw new Error("This methods was not overloaded by native module initialization")
     }
-    _ETSFunctionTypeIsThrowingConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
-        throw new Error("This methods was not overloaded by native module initialization")
-    }
-    _ETSFunctionTypeIsRethrowingConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
-        throw new Error("This methods was not overloaded by native module initialization")
-    }
     _ETSFunctionTypeIsExtensionFunctionConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
         throw new Error("This methods was not overloaded by native module initialization")
     }
@@ -278,9 +272,18 @@ export class Es2pandaNativeModule {
     _UpdateTSEnumDeclaration(context: KNativePointer, original: KNativePointer, key: KNativePointer, members: BigUint64Array, membersSequenceLength: KUInt, isConst: KBoolean, isStatic: KBoolean, isDeclare: KBoolean): KNativePointer {
         throw new Error("This methods was not overloaded by native module initialization")
     }
+    _CreateTSEnumDeclaration1(context: KNativePointer, key: KNativePointer, members: BigUint64Array, membersSequenceLength: KUInt, isConst: KBoolean, isStatic: KBoolean, isDeclare: KBoolean, typeNode: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _UpdateTSEnumDeclaration1(context: KNativePointer, original: KNativePointer, key: KNativePointer, members: BigUint64Array, membersSequenceLength: KUInt, isConst: KBoolean, isStatic: KBoolean, isDeclare: KBoolean, typeNode: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
     _TSEnumDeclarationKeyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer {
         throw new Error("This methods was not overloaded by native module initialization")
     }
+    _TSEnumDeclarationTypeNodes(context: KNativePointer, receiver: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
     _TSEnumDeclarationKey(context: KNativePointer, receiver: KNativePointer): KNativePointer {
         throw new Error("This methods was not overloaded by native module initialization")
     }
@@ -1310,13 +1313,10 @@ export class Es2pandaNativeModule {
     _ScriptFunctionHasThrowStatementConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
         throw new Error("This methods was not overloaded by native module initialization")
     }
-    _ScriptFunctionIsThrowingConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
-        throw new Error("This methods was not overloaded by native module initialization")
-    }
-    _ScriptFunctionIsRethrowingConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
+    _ScriptFunctionIsTrailingLambdaConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
         throw new Error("This methods was not overloaded by native module initialization")
     }
-    _ScriptFunctionIsTrailingLambdaConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
+    _ScriptFunctionIsSyntheticConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
         throw new Error("This methods was not overloaded by native module initialization")
     }
     _ScriptFunctionIsDynamicConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
@@ -2144,6 +2144,9 @@ export class Es2pandaNativeModule {
     _AstNodeGetOrCreateHistoryNodeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer {
         throw new Error("This methods was not overloaded by native module initialization")
     }
+    _AstNodeCleanCheckInformation(context: KNativePointer, receiver: KNativePointer): void {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
     _CreateUnaryExpression(context: KNativePointer, argument: KNativePointer, unaryOperator: KInt): KNativePointer {
         throw new Error("This methods was not overloaded by native module initialization")
     }
@@ -2651,6 +2654,30 @@ export class Es2pandaNativeModule {
     _UpdateCharLiteral(context: KNativePointer, original: KNativePointer): KNativePointer {
         throw new Error("This methods was not overloaded by native module initialization")
     }
+    _CreateETSIntrinsicNode(context: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _UpdateETSIntrinsicNode(context: KNativePointer, original: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _CreateETSIntrinsicNode1(context: KNativePointer, other: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _UpdateETSIntrinsicNode1(context: KNativePointer, original: KNativePointer, other: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _CreateETSIntrinsicNode2(context: KNativePointer, type: KInt, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _UpdateETSIntrinsicNode2(context: KNativePointer, original: KNativePointer, type: KInt, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _ETSIntrinsicNodeTypeConst(context: KNativePointer, receiver: KNativePointer): KInt {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _ETSIntrinsicNodeArgumentsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
     _CreateETSPackageDeclaration(context: KNativePointer, name: KNativePointer): KNativePointer {
         throw new Error("This methods was not overloaded by native module initialization")
     }
@@ -3164,6 +3191,15 @@ export class Es2pandaNativeModule {
     _ETSParameterExpressionSetIdent(context: KNativePointer, receiver: KNativePointer, ident: KNativePointer): void {
         throw new Error("This methods was not overloaded by native module initialization")
     }
+    _ETSParameterExpressionSpread(context: KNativePointer, receiver: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _ETSParameterExpressionSpreadConst(context: KNativePointer, receiver: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _ETSParameterExpressionSetSpread(context: KNativePointer, receiver: KNativePointer, spread: KNativePointer): void {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
     _ETSParameterExpressionRestParameterConst(context: KNativePointer, receiver: KNativePointer): KNativePointer {
         throw new Error("This methods was not overloaded by native module initialization")
     }
@@ -3674,6 +3710,45 @@ export class Es2pandaNativeModule {
     _MethodDefinitionSetValueOverloads(context: KNativePointer, receiver: KNativePointer, overloads: KNativePointer, index: KUInt): void {
         throw new Error("This methods was not overloaded by native module initialization")
     }
+    _CreateOverloadDeclaration(context: KNativePointer, key: KNativePointer, modifiers: KInt): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _UpdateOverloadDeclaration(context: KNativePointer, original: KNativePointer, key: KNativePointer, modifiers: KInt): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationFlagConst(context: KNativePointer, receiver: KNativePointer): KInt {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationOverloadedList(context: KNativePointer, receiver: KNativePointer): KNativePointer {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationSetOverloadedList(context: KNativePointer, receiver: KNativePointer, overloadedList: BigUint64Array, overloadedListSequenceLength: KUInt): void {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationPushFront(context: KNativePointer, receiver: KNativePointer, overloadedExpression: KNativePointer): void {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationAddOverloadDeclFlag(context: KNativePointer, receiver: KNativePointer, overloadFlag: KInt): void {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationHasOverloadDeclFlagConst(context: KNativePointer, receiver: KNativePointer, overloadFlag: KInt): KBoolean {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationIsConstructorOverloadDeclaration(context: KNativePointer, receiver: KNativePointer): KBoolean {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationIsFunctionOverloadDeclaration(context: KNativePointer, receiver: KNativePointer): KBoolean {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationIsClassMethodOverloadDeclaration(context: KNativePointer, receiver: KNativePointer): KBoolean {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationIsInterfaceMethodOverloadDeclaration(context: KNativePointer, receiver: KNativePointer): KBoolean {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _OverloadDeclarationDumpModifierConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
     _CreateTSNullKeyword(context: KNativePointer): KNativePointer {
         throw new Error("This methods was not overloaded by native module initialization")
     }
@@ -4562,6 +4637,12 @@ export class Es2pandaNativeModule {
     _ProgramIsStdLibConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
         throw new Error("This methods was not overloaded by native module initialization")
     }
+    _ProgramIsGenAbcForExternalConst(context: KNativePointer, receiver: KNativePointer): KBoolean {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
+    _ProgramSetGenAbcForExternalSources(context: KNativePointer, receiver: KNativePointer, genAbc: KBoolean): void {
+        throw new Error("This methods was not overloaded by native module initialization")
+    }
     _ProgramDumpConst(context: KNativePointer, receiver: KNativePointer): KStringPtr {
         throw new Error("This methods was not overloaded by native module initialization")
     }

package/build/libarkts-copy/src/generated/factory.ts

@@ -57,6 +57,7 @@ import { DebuggerStatement } from "./peers/DebuggerStatement"
 import { Decorator } from "./peers/Decorator"
 import { DoWhileStatement } from "./peers/DoWhileStatement"
 import { ETSClassLiteral } from "./peers/ETSClassLiteral"
+import { ETSIntrinsicNode } from "./peers/ETSIntrinsicNode"
 import { ETSKeyofType } from "./peers/ETSKeyofType"
 import { ETSNewArrayInstanceExpression } from "./peers/ETSNewArrayInstanceExpression"
 import { ETSNewClassInstanceExpression } from "./peers/ETSNewClassInstanceExpression"
@@ -68,7 +69,9 @@ import { ETSTypeReferencePart } from "./peers/ETSTypeReferencePart"
 import { ETSUndefinedType } from "./peers/ETSUndefinedType"
 import { ETSUnionType } from "./peers/ETSUnionType"
 import { EmptyStatement } from "./peers/EmptyStatement"
+import { Es2pandaIntrinsicNodeType } from "./Es2pandaEnums"
 import { Es2pandaMetaPropertyKind } from "./Es2pandaEnums"
+import { Es2pandaModifierFlags } from "./Es2pandaEnums"
 import { Es2pandaPrimitiveType } from "./Es2pandaEnums"
 import { Es2pandaPropertyKind } from "./Es2pandaEnums"
 import { Es2pandaTokenType } from "./Es2pandaEnums"
@@ -331,14 +334,14 @@ export const factory = {
         return updateNodeByNode(TemplateElement.create1TemplateElement(raw, cooked), original)
     }
     ,
-    createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[]): VariableDeclaration {
-        return VariableDeclaration.createVariableDeclaration(kind, declarators)
+    createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], annotations?: readonly AnnotationUsage[]): VariableDeclaration {
+        return VariableDeclaration.createVariableDeclaration(kind, declarators, annotations)
     }
     ,
-    updateVariableDeclaration(original: VariableDeclaration, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[]): VariableDeclaration {
-        if (isSameNativeObject(kind, original.kind) && isSameNativeObject(declarators, original.declarators))
+    updateVariableDeclaration(original: VariableDeclaration, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], annotations?: readonly AnnotationUsage[]): VariableDeclaration {
+        if (isSameNativeObject(kind, original.kind) && isSameNativeObject(declarators, original.declarators) && isSameNativeObject(annotations, original.annotations))
             return original
-        return updateNodeByNode(VariableDeclaration.createVariableDeclaration(kind, declarators), original)
+        return updateNodeByNode(VariableDeclaration.createVariableDeclaration(kind, declarators, annotations), original)
     }
     ,
     createUndefinedLiteral(): UndefinedLiteral {
@@ -367,14 +370,14 @@ export const factory = {
         return updateNodeByNode(TSObjectKeyword.createTSObjectKeyword(), original)
     }
     ,
-    createETSUnionType(types: readonly TypeNode[]): ETSUnionType {
-        return ETSUnionType.createETSUnionType(types)
+    createETSUnionType(types: readonly TypeNode[], annotations?: readonly AnnotationUsage[]): ETSUnionType {
+        return ETSUnionType.createETSUnionType(types, annotations)
     }
     ,
-    updateETSUnionType(original: ETSUnionType, types: readonly TypeNode[]): ETSUnionType {
-        if (isSameNativeObject(types, original.types))
+    updateETSUnionType(original: ETSUnionType, types: readonly TypeNode[], annotations?: readonly AnnotationUsage[]): ETSUnionType {
+        if (isSameNativeObject(types, original.types) && isSameNativeObject(annotations, original.annotations))
             return original
-        return updateNodeByNode(ETSUnionType.createETSUnionType(types), original)
+        return updateNodeByNode(ETSUnionType.createETSUnionType(types, annotations), original)
     }
     ,
     createETSKeyofType(typeRef?: TypeNode): ETSKeyofType {
@@ -407,14 +410,14 @@ export const factory = {
         return updateNodeByNode(TSLiteralType.createTSLiteralType(literal), original)
     }
     ,
-    createTSTypeAliasDeclaration(id: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, typeAnnotation: TypeNode): TSTypeAliasDeclaration {
-        return TSTypeAliasDeclaration.createTSTypeAliasDeclaration(id, typeParams, typeAnnotation)
+    createTSTypeAliasDeclaration(id: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, typeAnnotation: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
+        return TSTypeAliasDeclaration.createTSTypeAliasDeclaration(id, typeParams, typeAnnotation, annotations, modifierFlags)
     }
     ,
-    updateTSTypeAliasDeclaration(original: TSTypeAliasDeclaration, id: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, typeAnnotation: TypeNode): TSTypeAliasDeclaration {
-        if (isSameNativeObject(id, original.id) && isSameNativeObject(typeParams, original.typeParams) && isSameNativeObject(typeAnnotation, original.typeAnnotation))
+    updateTSTypeAliasDeclaration(original: TSTypeAliasDeclaration, id: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, typeAnnotation: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
+        if (isSameNativeObject(id, original.id) && isSameNativeObject(typeParams, original.typeParams) && isSameNativeObject(typeAnnotation, original.typeAnnotation) && isSameNativeObject(annotations, original.annotations) && isSameNativeObject(modifierFlags, original.modifierFlags))
             return original
-        return updateNodeByNode(TSTypeAliasDeclaration.createTSTypeAliasDeclaration(id, typeParams, typeAnnotation), original)
+        return updateNodeByNode(TSTypeAliasDeclaration.createTSTypeAliasDeclaration(id, typeParams, typeAnnotation, annotations, modifierFlags), original)
     }
     ,
     createDebuggerStatement(): DebuggerStatement {
@@ -673,6 +676,16 @@ export const factory = {
         return updateNodeByNode(CharLiteral.createCharLiteral(), original)
     }
     ,
+    createETSIntrinsicNode(type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode {
+        return ETSIntrinsicNode.create2ETSIntrinsicNode(type, _arguments)
+    }
+    ,
+    updateETSIntrinsicNode(original: ETSIntrinsicNode, type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode {
+        if (isSameNativeObject(type, original.type) && isSameNativeObject(_arguments, original.arguments))
+            return original
+        return updateNodeByNode(ETSIntrinsicNode.create2ETSIntrinsicNode(type, _arguments), original)
+    }
+    ,
     createTSModuleBlock(statements: readonly Statement[]): TSModuleBlock {
         return TSModuleBlock.createTSModuleBlock(statements)
     }
@@ -1039,14 +1052,14 @@ export const factory = {
         return updateNodeByNode(TSAnyKeyword.createTSAnyKeyword(), original)
     }
     ,
-    createClassDeclaration(definition?: ClassDefinition): ClassDeclaration {
-        return ClassDeclaration.createClassDeclaration(definition)
+    createClassDeclaration(definition?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
+        return ClassDeclaration.createClassDeclaration(definition, modifierFlags)
     }
     ,
-    updateClassDeclaration(original: ClassDeclaration, definition?: ClassDefinition): ClassDeclaration {
-        if (isSameNativeObject(definition, original.definition))
+    updateClassDeclaration(original: ClassDeclaration, definition?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
+        if (isSameNativeObject(definition, original.definition) && isSameNativeObject(modifierFlags, original.modifierFlags))
             return original
-        return updateNodeByNode(ClassDeclaration.createClassDeclaration(definition), original)
+        return updateNodeByNode(ClassDeclaration.createClassDeclaration(definition, modifierFlags), original)
     }
     ,
     createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType {
@@ -1195,14 +1208,14 @@ export const factory = {
         return updateNodeByNode(SequenceExpression.createSequenceExpression(sequence), original)
     }
     ,
-    createArrowFunctionExpression(_function?: ScriptFunction): ArrowFunctionExpression {
-        return ArrowFunctionExpression.createArrowFunctionExpression(_function)
+    createArrowFunctionExpression(_function?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
+        return ArrowFunctionExpression.createArrowFunctionExpression(_function, annotations)
     }
     ,
-    updateArrowFunctionExpression(original: ArrowFunctionExpression, _function?: ScriptFunction): ArrowFunctionExpression {
-        if (isSameNativeObject(_function, original.function))
+    updateArrowFunctionExpression(original: ArrowFunctionExpression, _function?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
+        if (isSameNativeObject(_function, original.function) && isSameNativeObject(annotations, original.annotations))
             return original
-        return updateNodeByNode(ArrowFunctionExpression.createArrowFunctionExpression(_function), original)
+        return updateNodeByNode(ArrowFunctionExpression.createArrowFunctionExpression(_function, annotations), original)
     }
     ,
     createOmittedExpression(): OmittedExpression {

package/build/libarkts-copy/src/generated/index.ts

@@ -125,6 +125,7 @@ export * from "./peers/ImportDeclaration"
 export * from "./peers/TSParenthesizedType"
 export * from "./peers/Literal"
 export * from "./peers/CharLiteral"
+export * from "./peers/ETSIntrinsicNode"
 export * from "./peers/ETSPackageDeclaration"
 export * from "./peers/ETSImportDeclaration"
 export * from "./peers/ETSStructDeclaration"
@@ -171,6 +172,7 @@ export * from "./peers/Statement"
 export * from "./peers/DirectEvalExpression"
 export * from "./peers/TSTypeParameterDeclaration"
 export * from "./peers/MethodDefinition"
+export * from "./peers/OverloadDeclaration"
 export * from "./peers/TSNullKeyword"
 export * from "./peers/TSInterfaceHeritage"
 export * from "./peers/Expression"

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

@@ -41,7 +41,7 @@ import { ValidationInfo } from "./ValidationInfo"
 
 export class ArrayExpression extends AnnotatedExpression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 157)
+        assertValidPeer(pointer, 159)
         super(pointer)
     }
     static create1ArrayExpression(nodeType: Es2pandaAstNodeType, elements: readonly Expression[], trailingComma: boolean): ArrayExpression {

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

@@ -43,18 +43,30 @@ export class ArrowFunctionExpression extends Expression {
         assertValidPeer(pointer, 0)
         super(pointer)
     }
-    static createArrowFunctionExpression(func?: ScriptFunction): ArrowFunctionExpression {
+    static createArrowFunctionExpression(func?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
         const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func)))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction): ArrowFunctionExpression {
+    static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
         const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression(global.context, passNode(original), passNode(func)))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression): ArrowFunctionExpression {
+    static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
         const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other)))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }

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

@@ -39,7 +39,7 @@ import { Expression } from "./Expression"
 
 export class AssignmentExpression extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 159)
+        assertValidPeer(pointer, 161)
         super(pointer)
     }
     static create1AssignmentExpression(type: Es2pandaAstNodeType, left: Expression | undefined, right: Expression | undefined, assignmentOperator: Es2pandaTokenType): AssignmentExpression {

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

@@ -38,7 +38,7 @@ import { Statement } from "./Statement"
 
 export class BlockExpression extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 155)
+        assertValidPeer(pointer, 157)
         super(pointer)
     }
     static createBlockExpression(statements: readonly Statement[]): BlockExpression {

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

@@ -43,13 +43,21 @@ export class CallExpression extends MaybeOptionalExpression {
         assertValidPeer(pointer, 10)
         super(pointer)
     }
-    static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean): CallExpression {
+    static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean, trailingBlock?: BlockStatement): CallExpression {
         const result: CallExpression = new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, trailingComma))
+        if (trailingBlock)
+        {
+            result.setTrailingBlock(trailingBlock)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static update1CallExpression(original?: CallExpression, other?: CallExpression): CallExpression {
+    static update1CallExpression(original?: CallExpression, other?: CallExpression, trailingBlock?: BlockStatement): CallExpression {
         const result: CallExpression = new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other)))
+        if (trailingBlock)
+        {
+            result.setTrailingBlock(trailingBlock)
+        }
         result.setChildrenParentPtr()
         return result
     }

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

@@ -35,6 +35,7 @@ import {
 import { ClassDefinition } from "./ClassDefinition"
 import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
+import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 
 export class ClassDeclaration extends Statement {
@@ -42,13 +43,21 @@ export class ClassDeclaration extends Statement {
         assertValidPeer(pointer, 15)
         super(pointer)
     }
-    static createClassDeclaration(def?: ClassDefinition): ClassDeclaration {
+    static createClassDeclaration(def?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
         const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def)))
+        if (modifierFlags)
+        {
+            result.modifierFlags = modifierFlags
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition): ClassDeclaration {
+    static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
         const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def)))
+        if (modifierFlags)
+        {
+            result.modifierFlags = modifierFlags
+        }
         result.setChildrenParentPtr()
         return result
     }

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

@@ -51,23 +51,39 @@ export class ClassDefinition extends TypedAstNode {
         assertValidPeer(pointer, 14)
         super(pointer)
     }
-    static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition {
+    static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
         const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._CreateClassDefinition(global.context, passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition {
+    static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
         const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition(global.context, passNode(original), passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition {
+    static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
         const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition1(global.context, passNode(original), passNode(ident), passNodeArray(body), body.length, modifiers, flags))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition {
+    static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
         const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition2(global.context, passNode(original), passNode(ident), modifiers, flags))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }

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

@@ -44,13 +44,21 @@ export class ClassProperty extends ClassElement {
         assertValidPeer(pointer, 17)
         super(pointer)
     }
-    static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty {
+    static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, annotations?: readonly AnnotationUsage[]): ClassProperty {
         const result: ClassProperty = new ClassProperty(global.generatedEs2panda._CreateClassProperty(global.context, passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty {
+    static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, annotations?: readonly AnnotationUsage[]): ClassProperty {
         const result: ClassProperty = new ClassProperty(global.generatedEs2panda._UpdateClassProperty(global.context, passNode(original), passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }

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

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSClassLiteral extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 71)
+        assertValidPeer(pointer, 73)
         super(pointer)
     }
     static createETSClassLiteral(expr?: TypeNode): ETSClassLiteral {

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

@@ -32,6 +32,7 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { AnnotationUsage } from "./AnnotationUsage"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaScriptFunctionFlags } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
@@ -42,16 +43,24 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSFunctionType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 67)
+        assertValidPeer(pointer, 69)
         super(pointer)
     }
-    static createETSFunctionType(signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags): ETSFunctionType {
+    static createETSFunctionType(signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags, annotations?: readonly AnnotationUsage[]): ETSFunctionType {
         const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._CreateETSFunctionType(global.context, passNode(signature), funcFlags))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateETSFunctionType(original: ETSFunctionType | undefined, signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags): ETSFunctionType {
+    static updateETSFunctionType(original: ETSFunctionType | undefined, signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags, annotations?: readonly AnnotationUsage[]): ETSFunctionType {
         const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._UpdateETSFunctionType(global.context, passNode(original), passNode(signature), funcFlags))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
@@ -75,12 +84,6 @@ export class ETSFunctionType extends TypeNode {
     get flags(): Es2pandaScriptFunctionFlags {
         return global.generatedEs2panda._ETSFunctionTypeFlags(global.context, this.peer)
     }
-    get isThrowing(): boolean {
-        return global.generatedEs2panda._ETSFunctionTypeIsThrowingConst(global.context, this.peer)
-    }
-    get isRethrowing(): boolean {
-        return global.generatedEs2panda._ETSFunctionTypeIsRethrowingConst(global.context, this.peer)
-    }
     get isExtensionFunction(): boolean {
         return global.generatedEs2panda._ETSFunctionTypeIsExtensionFunctionConst(global.context, this.peer)
     }

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

@@ -41,7 +41,7 @@ import { StringLiteral } from "./StringLiteral"
 
 export class ETSImportDeclaration extends ImportDeclaration {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 79)
+        assertValidPeer(pointer, 81)
         super(pointer)
     }
     static createETSImportDeclaration(importPath: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ETSImportDeclaration {