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

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

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY!
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
+import { Es2pandaIntrinsicNodeType } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+
+export class ETSIntrinsicNode extends Expression {
+    constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 68)
+        super(pointer)
+    }
+    static create2ETSIntrinsicNode(type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode {
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._CreateETSIntrinsicNode2(global.context, type, passNodeArray(_arguments), _arguments.length))
+        result.setChildrenParentPtr()
+        return result
+    }
+    static updateETSIntrinsicNode(original?: ETSIntrinsicNode): ETSIntrinsicNode {
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode(global.context, passNode(original)))
+        result.setChildrenParentPtr()
+        return result
+    }
+    static update1ETSIntrinsicNode(original?: ETSIntrinsicNode, other?: ETSIntrinsicNode): ETSIntrinsicNode {
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode1(global.context, passNode(original), passNode(other)))
+        result.setChildrenParentPtr()
+        return result
+    }
+    static update2ETSIntrinsicNode(original: ETSIntrinsicNode | undefined, type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode {
+        const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode2(global.context, passNode(original), type, passNodeArray(_arguments), _arguments.length))
+        result.setChildrenParentPtr()
+        return result
+    }
+    get type(): Es2pandaIntrinsicNodeType {
+        return global.generatedEs2panda._ETSIntrinsicNodeTypeConst(global.context, this.peer)
+    }
+    get arguments(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._ETSIntrinsicNodeArgumentsConst(global.context, this.peer))
+    }
+    protected readonly brandETSIntrinsicNode: undefined
+}
+export function isETSIntrinsicNode(node: object | undefined): node is ETSIntrinsicNode {
+    return node instanceof ETSIntrinsicNode
+}
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE, (peer: KNativePointer) => new ETSIntrinsicNode(peer))
+}

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

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSKeyofType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 75)
+        assertValidPeer(pointer, 77)
         super(pointer)
     }
     static createETSKeyofType(type?: TypeNode): ETSKeyofType {

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

@@ -40,10 +40,11 @@ import { Es2pandaModuleFlag } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
 import { Program } from "./Program"
 import { Statement } from "./Statement"
+import { extension_ETSModuleGetNamespaceFlag } from "./../../reexport-for-generated"
 
 export class ETSModule extends BlockStatement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 82)
+        assertValidPeer(pointer, 84)
         super(pointer)
     }
     static createETSModule(statementList: readonly Statement[], ident: Identifier | undefined, flag: Es2pandaModuleFlag, program?: Program): ETSModule {
@@ -120,6 +121,7 @@ export class ETSModule extends BlockStatement {
         global.generatedEs2panda._ETSModuleAddAnnotations(global.context, this.peer, passNode(annotations))
         return this
     }
+    getNamespaceFlag = extension_ETSModuleGetNamespaceFlag
     protected readonly brandETSModule: undefined
 }
 export function isETSModule(node: object | undefined): node is ETSModule {

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

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSNewArrayInstanceExpression extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 76)
+        assertValidPeer(pointer, 78)
         super(pointer)
     }
     static createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression {

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

@@ -37,7 +37,7 @@ import { Expression } from "./Expression"
 
 export class ETSNewClassInstanceExpression extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 78)
+        assertValidPeer(pointer, 80)
         super(pointer)
     }
     static createETSNewClassInstanceExpression(typeReference: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression {

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

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSNewMultiDimArrayInstanceExpression extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 77)
+        assertValidPeer(pointer, 79)
         super(pointer)
     }
     static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression {

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

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSNullType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 63)
+        assertValidPeer(pointer, 64)
         super(pointer)
     }
     static createETSNullType(): ETSNullType {

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

@@ -38,7 +38,7 @@ import { Statement } from "./Statement"
 
 export class ETSPackageDeclaration extends Statement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 70)
+        assertValidPeer(pointer, 72)
         super(pointer)
     }
     static createETSPackageDeclaration(name?: Expression): ETSPackageDeclaration {

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

@@ -42,26 +42,42 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSParameterExpression extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 80)
+        assertValidPeer(pointer, 82)
         super(pointer)
     }
-    static createETSParameterExpression(identOrSpread: AnnotatedExpression | undefined, isOptional: boolean): ETSParameterExpression {
+    static createETSParameterExpression(identOrSpread: AnnotatedExpression | undefined, isOptional: boolean, annotations?: readonly AnnotationUsage[]): ETSParameterExpression {
         const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression(global.context, passNode(identOrSpread), isOptional))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateETSParameterExpression(original: ETSParameterExpression | undefined, identOrSpread: AnnotatedExpression | undefined, isOptional: boolean): ETSParameterExpression {
+    static updateETSParameterExpression(original: ETSParameterExpression | undefined, identOrSpread: AnnotatedExpression | undefined, isOptional: boolean, annotations?: readonly AnnotationUsage[]): ETSParameterExpression {
         const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression(global.context, passNode(original), passNode(identOrSpread), isOptional))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static create1ETSParameterExpression(identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression {
+    static create1ETSParameterExpression(identOrSpread?: AnnotatedExpression, initializer?: Expression, annotations?: readonly AnnotationUsage[]): ETSParameterExpression {
         const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression1(global.context, passNode(identOrSpread), passNode(initializer)))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static update1ETSParameterExpression(original?: ETSParameterExpression, identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression {
+    static update1ETSParameterExpression(original?: ETSParameterExpression, identOrSpread?: AnnotatedExpression, initializer?: Expression, annotations?: readonly AnnotationUsage[]): ETSParameterExpression {
         const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression1(global.context, passNode(original), passNode(identOrSpread), passNode(initializer)))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
@@ -76,6 +92,14 @@ export class ETSParameterExpression extends Expression {
         global.generatedEs2panda._ETSParameterExpressionSetIdent(global.context, this.peer, passNode(ident))
         return this
     }
+    get spread(): SpreadElement | undefined {
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionSpread(global.context, this.peer))
+    }
+    /** @deprecated */
+    setSpread(spread?: SpreadElement): this {
+        global.generatedEs2panda._ETSParameterExpressionSetSpread(global.context, this.peer, passNode(spread))
+        return this
+    }
     get restParameter(): SpreadElement | undefined {
         return unpackNode(global.generatedEs2panda._ETSParameterExpressionRestParameter(global.context, this.peer))
     }

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

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSPrimitiveType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 69)
+        assertValidPeer(pointer, 71)
         super(pointer)
     }
     static createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType {

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

@@ -38,7 +38,7 @@ import { Statement } from "./Statement"
 
 export class ETSReExportDeclaration extends Statement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 57)
+        assertValidPeer(pointer, 58)
         super(pointer)
     }
     get eTSImportDeclarations(): ETSImportDeclaration | undefined {

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

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSStringLiteralType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 66)
+        assertValidPeer(pointer, 67)
         super(pointer)
     }
     static createETSStringLiteralType(value: string): ETSStringLiteralType {

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

@@ -38,7 +38,7 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 
 export class ETSStructDeclaration extends ClassDeclaration {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 84)
+        assertValidPeer(pointer, 86)
         super(pointer)
     }
     static createETSStructDeclaration(def?: ClassDefinition): ETSStructDeclaration {

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

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSTuple extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 81)
+        assertValidPeer(pointer, 83)
         super(pointer)
     }
     static createETSTuple(): ETSTuple {

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

@@ -39,7 +39,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSTypeReference extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 72)
+        assertValidPeer(pointer, 74)
         super(pointer)
     }
     static createETSTypeReference(part?: ETSTypeReferencePart): ETSTypeReference {

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

@@ -40,7 +40,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSTypeReferencePart extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 73)
+        assertValidPeer(pointer, 75)
         super(pointer)
     }
     static createETSTypeReferencePart(name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart {

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

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSUndefinedType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 64)
+        assertValidPeer(pointer, 65)
         super(pointer)
     }
     static createETSUndefinedType(): ETSUndefinedType {

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

@@ -32,21 +32,30 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { AnnotationUsage } from "./AnnotationUsage"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class ETSUnionType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 74)
+        assertValidPeer(pointer, 76)
         super(pointer)
     }
-    static createETSUnionType(types: readonly TypeNode[]): ETSUnionType {
+    static createETSUnionType(types: readonly TypeNode[], annotations?: readonly AnnotationUsage[]): ETSUnionType {
         const result: ETSUnionType = new ETSUnionType(global.generatedEs2panda._CreateETSUnionType(global.context, passNodeArray(types), types.length))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[]): ETSUnionType {
+    static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[], annotations?: readonly AnnotationUsage[]): ETSUnionType {
         const result: ETSUnionType = new ETSUnionType(global.generatedEs2panda._UpdateETSUnionType(global.context, passNode(original), passNodeArray(types), types.length))
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }

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

@@ -39,7 +39,7 @@ import { TypeNode } from "./TypeNode"
 
 export class ETSWildcardType extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 68)
+        assertValidPeer(pointer, 70)
         super(pointer)
     }
     static createETSWildcardType(typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType {

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

@@ -38,19 +38,29 @@ import { Es2pandaMethodDefinitionKind } from "./../Es2pandaEnums"
 import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { ScriptFunction } from "./ScriptFunction"
+import { extension_MethodDefinitionOnUpdate } from "./../../reexport-for-generated"
+import { extension_MethodDefinitionSetChildrenParentPtr } from "./../../reexport-for-generated"
 
 export class MethodDefinition extends ClassElement {
     constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 47)
         super(pointer)
     }
-    static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition {
+    static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, overloads?: readonly MethodDefinition[]): MethodDefinition {
         const result: MethodDefinition = new MethodDefinition(global.generatedEs2panda._CreateMethodDefinition(global.context, kind, passNode(key), passNode(value), modifiers, isComputed))
+        if (overloads)
+        {
+            result.setOverloads(overloads)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateMethodDefinition(original: MethodDefinition | undefined, kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition {
+    static updateMethodDefinition(original: MethodDefinition | undefined, kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, overloads?: readonly MethodDefinition[]): MethodDefinition {
         const result: MethodDefinition = new MethodDefinition(global.generatedEs2panda._UpdateMethodDefinition(global.context, passNode(original), kind, passNode(key), passNode(value), modifiers, isComputed))
+        if (overloads)
+        {
+            result.setOverloads(overloads)
+        }
         result.setChildrenParentPtr()
         return result
     }
@@ -132,6 +142,8 @@ export class MethodDefinition extends ClassElement {
         global.generatedEs2panda._MethodDefinitionSetValueOverloads(global.context, this.peer, passNode(overloads), index)
         return this
     }
+    setChildrenParentPtr = extension_MethodDefinitionSetChildrenParentPtr
+    onUpdate = extension_MethodDefinitionOnUpdate
     protected readonly brandMethodDefinition: undefined
 }
 export function isMethodDefinition(node: object | undefined): node is MethodDefinition {

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

@@ -41,7 +41,7 @@ import { ValidationInfo } from "./ValidationInfo"
 
 export class ObjectExpression extends AnnotatedExpression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 161)
+        assertValidPeer(pointer, 163)
         super(pointer)
     }
     static createObjectExpression(nodeType: Es2pandaAstNodeType, properties: readonly Expression[], trailingComma: boolean): ObjectExpression {

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

@@ -37,7 +37,7 @@ import { TypeNode } from "./TypeNode"
 
 export class OpaqueTypeNode extends TypeNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 154)
+        assertValidPeer(pointer, 156)
         super(pointer)
     }
     static create1OpaqueTypeNode(): OpaqueTypeNode {

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

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY!
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { ClassElement } from "./ClassElement"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
+import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
+import { Es2pandaOverloadDeclFlags } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { Identifier } from "./Identifier"
+import { SrcDumper } from "./SrcDumper"
+
+export class OverloadDeclaration extends ClassElement {
+    constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 54)
+        super(pointer)
+    }
+    static createOverloadDeclaration(key: Expression | undefined, modifiers: Es2pandaModifierFlags): OverloadDeclaration {
+        const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._CreateOverloadDeclaration(global.context, passNode(key), modifiers))
+        result.setChildrenParentPtr()
+        return result
+    }
+    static updateOverloadDeclaration(original: OverloadDeclaration | undefined, key: Expression | undefined, modifiers: Es2pandaModifierFlags): OverloadDeclaration {
+        const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._UpdateOverloadDeclaration(global.context, passNode(original), passNode(key), modifiers))
+        result.setChildrenParentPtr()
+        return result
+    }
+    get flag(): Es2pandaOverloadDeclFlags {
+        return global.generatedEs2panda._OverloadDeclarationFlagConst(global.context, this.peer)
+    }
+    get overloadedList(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._OverloadDeclarationOverloadedList(global.context, this.peer))
+    }
+    /** @deprecated */
+    setOverloadedList(overloadedList: readonly Expression[]): this {
+        global.generatedEs2panda._OverloadDeclarationSetOverloadedList(global.context, this.peer, passNodeArray(overloadedList), overloadedList.length)
+        return this
+    }
+    /** @deprecated */
+    pushFront(overloadedExpression?: Identifier): this {
+        global.generatedEs2panda._OverloadDeclarationPushFront(global.context, this.peer, passNode(overloadedExpression))
+        return this
+    }
+    /** @deprecated */
+    addOverloadDeclFlag(overloadFlag: Es2pandaOverloadDeclFlags): this {
+        global.generatedEs2panda._OverloadDeclarationAddOverloadDeclFlag(global.context, this.peer, overloadFlag)
+        return this
+    }
+    get isConstructorOverloadDeclaration(): boolean {
+        return global.generatedEs2panda._OverloadDeclarationIsConstructorOverloadDeclaration(global.context, this.peer)
+    }
+    get isFunctionOverloadDeclaration(): boolean {
+        return global.generatedEs2panda._OverloadDeclarationIsFunctionOverloadDeclaration(global.context, this.peer)
+    }
+    get isClassMethodOverloadDeclaration(): boolean {
+        return global.generatedEs2panda._OverloadDeclarationIsClassMethodOverloadDeclaration(global.context, this.peer)
+    }
+    get isInterfaceMethodOverloadDeclaration(): boolean {
+        return global.generatedEs2panda._OverloadDeclarationIsInterfaceMethodOverloadDeclaration(global.context, this.peer)
+    }
+    /** @deprecated */
+    dumpModifier(dumper?: SrcDumper): this {
+        global.generatedEs2panda._OverloadDeclarationDumpModifierConst(global.context, this.peer, passNode(dumper))
+        return this
+    }
+    protected readonly brandOverloadDeclaration: undefined
+}
+export function isOverloadDeclaration(node: object | undefined): node is OverloadDeclaration {
+    return node instanceof OverloadDeclaration
+}
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION, (peer: KNativePointer) => new OverloadDeclaration(peer))
+}

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

@@ -38,7 +38,7 @@ import { TypeNode } from "./TypeNode"
 
 export class PrefixAssertionExpression extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 54)
+        assertValidPeer(pointer, 55)
         super(pointer)
     }
     static createPrefixAssertionExpression(expr?: Expression, type?: TypeNode): PrefixAssertionExpression {

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

@@ -166,6 +166,14 @@ export class Program extends ArktsObject {
     get isStdLib(): boolean {
         return global.generatedEs2panda._ProgramIsStdLibConst(global.context, this.peer)
     }
+    get isGenAbcForExternal(): boolean {
+        return global.generatedEs2panda._ProgramIsGenAbcForExternalConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setGenAbcForExternalSources(genAbc: boolean): this {
+        global.generatedEs2panda._ProgramSetGenAbcForExternalSources(global.context, this.peer, genAbc)
+        return this
+    }
     get dump(): string {
         return unpackString(global.generatedEs2panda._ProgramDumpConst(global.context, this.peer))
     }

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

@@ -39,7 +39,7 @@ import { ValidationInfo } from "./ValidationInfo"
 
 export class Property extends Expression {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 55)
+        assertValidPeer(pointer, 56)
         super(pointer)
     }
     static create1Property(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property {

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

@@ -38,7 +38,7 @@ import { Literal } from "./Literal"
 
 export class RegExpLiteral extends Literal {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 56)
+        assertValidPeer(pointer, 57)
         super(pointer)
     }
     static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral {

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

@@ -38,7 +38,7 @@ import { Statement } from "./Statement"
 
 export class ReturnStatement extends Statement {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 58)
+        assertValidPeer(pointer, 59)
         super(pointer)
     }
     static create1ReturnStatement(argument?: Expression): ReturnStatement {

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

@@ -41,19 +41,37 @@ import { Identifier } from "./Identifier"
 import { ReturnStatement } from "./ReturnStatement"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
+import { extension_ScriptFunctionGetPreferredReturnTypePointer } from "./../../reexport-for-generated"
+import { extension_ScriptFunctionSetPreferredReturnTypePointer } from "./../../reexport-for-generated"
 
 export class ScriptFunction extends AstNode {
     constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 59)
+        assertValidPeer(pointer, 60)
         super(pointer)
     }
-    static createScriptFunction(databody: AstNode | undefined, datasignature: FunctionSignature | undefined, datafuncFlags: number, dataflags: number): ScriptFunction {
+    static createScriptFunction(databody: AstNode | undefined, datasignature: FunctionSignature | undefined, datafuncFlags: number, dataflags: number, ident?: Identifier, annotations?: readonly AnnotationUsage[]): ScriptFunction {
         const result: ScriptFunction = new ScriptFunction(global.generatedEs2panda._CreateScriptFunction(global.context, passNode(databody), passNode(datasignature), datafuncFlags, dataflags))
+        if (ident)
+        {
+            result.setIdent(ident)
+        }
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
-    static updateScriptFunction(original: ScriptFunction | undefined, databody: AstNode | undefined, datasignature: FunctionSignature | undefined, datafuncFlags: number, dataflags: number): ScriptFunction {
+    static updateScriptFunction(original: ScriptFunction | undefined, databody: AstNode | undefined, datasignature: FunctionSignature | undefined, datafuncFlags: number, dataflags: number, ident?: Identifier, annotations?: readonly AnnotationUsage[]): ScriptFunction {
         const result: ScriptFunction = new ScriptFunction(global.generatedEs2panda._UpdateScriptFunction(global.context, passNode(original), passNode(databody), passNode(datasignature), datafuncFlags, dataflags))
+        if (ident)
+        {
+            result.setIdent(ident)
+        }
+        if (annotations)
+        {
+            result.setAnnotations(annotations)
+        }
         result.setChildrenParentPtr()
         return result
     }
@@ -159,15 +177,12 @@ export class ScriptFunction extends AstNode {
     get hasThrowStatement(): boolean {
         return global.generatedEs2panda._ScriptFunctionHasThrowStatementConst(global.context, this.peer)
     }
-    get isThrowing(): boolean {
-        return global.generatedEs2panda._ScriptFunctionIsThrowingConst(global.context, this.peer)
-    }
-    get isRethrowing(): boolean {
-        return global.generatedEs2panda._ScriptFunctionIsRethrowingConst(global.context, this.peer)
-    }
     get isTrailingLambda(): boolean {
         return global.generatedEs2panda._ScriptFunctionIsTrailingLambdaConst(global.context, this.peer)
     }
+    get isSynthetic(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsSyntheticConst(global.context, this.peer)
+    }
     get isDynamic(): boolean {
         return global.generatedEs2panda._ScriptFunctionIsDynamicConst(global.context, this.peer)
     }
@@ -267,6 +282,8 @@ export class ScriptFunction extends AstNode {
         global.generatedEs2panda._ScriptFunctionAddAnnotations(global.context, this.peer, passNode(annotations))
         return this
     }
+    getPreferredReturnTypePointer = extension_ScriptFunctionGetPreferredReturnTypePointer
+    setPreferredReturnTypePointer = extension_ScriptFunctionSetPreferredReturnTypePointer
     protected readonly brandScriptFunction: undefined
 }
 export function isScriptFunction(node: object | undefined): node is ScriptFunction {