@idlizer/arktscgen 2.1.2 → 2.1.5

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class ETSClassLiteral extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 70)
         super(pointer)
     }
@@ -49,6 +49,6 @@ export class ETSClassLiteral extends Expression {
 export function isETSClassLiteral(node: object | undefined): node is ETSClassLiteral {
     return node instanceof ETSClassLiteral
 }
-if (!nodeByType.has(70)) {
-    nodeByType.set(70, ETSClassLiteral)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL, (peer: KNativePointer) => new ETSClassLiteral(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,7 +30,7 @@ import {
 
 import { ETSFunctionType } from "./ETSFunctionType"
 export class ETSDynamicFunctionType extends ETSFunctionType {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
 }

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

@@ -22,13 +22,13 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaScriptFunctionFlags } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { FunctionSignature } from "./FunctionSignature"
@@ -36,49 +36,49 @@ import { TSInterfaceDeclaration } from "./TSInterfaceDeclaration"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 export class ETSFunctionType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 66)
         super(pointer)
     }
     static createETSFunctionType(signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags): ETSFunctionType {
-        return new ETSFunctionType(global.generatedEs2panda._CreateETSFunctionTypeIr(global.context, passNode(signature), funcFlags))
+        return new ETSFunctionType(global.generatedEs2panda._CreateETSFunctionType(global.context, passNode(signature), funcFlags))
     }
     static updateETSFunctionType(original: ETSFunctionType | undefined, signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags): ETSFunctionType {
-        return new ETSFunctionType(global.generatedEs2panda._UpdateETSFunctionTypeIr(global.context, passNode(original), passNode(signature), funcFlags))
+        return new ETSFunctionType(global.generatedEs2panda._UpdateETSFunctionType(global.context, passNode(original), passNode(signature), funcFlags))
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSFunctionTypeTypeParams(global.context, this.peer))
     }
     get params(): readonly Expression[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSFunctionTypeIrParamsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSFunctionTypeParamsConst(global.context, this.peer))
     }
     get returnType(): TypeNode | undefined {
-        return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrReturnTypeConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSFunctionTypeReturnType(global.context, this.peer))
     }
     get functionalInterface(): TSInterfaceDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrFunctionalInterfaceConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSFunctionTypeFunctionalInterface(global.context, this.peer))
     }
     /** @deprecated */
     setFunctionalInterface(functionalInterface?: TSInterfaceDeclaration): this {
-        global.generatedEs2panda._ETSFunctionTypeIrSetFunctionalInterface(global.context, this.peer, passNode(functionalInterface))
+        global.generatedEs2panda._ETSFunctionTypeSetFunctionalInterface(global.context, this.peer, passNode(functionalInterface))
         return this
     }
     get flags(): Es2pandaScriptFunctionFlags {
-        return global.generatedEs2panda._ETSFunctionTypeIrFlags(global.context, this.peer)
+        return global.generatedEs2panda._ETSFunctionTypeFlags(global.context, this.peer)
     }
     get isThrowing(): boolean {
-        return global.generatedEs2panda._ETSFunctionTypeIrIsThrowingConst(global.context, this.peer)
+        return global.generatedEs2panda._ETSFunctionTypeIsThrowingConst(global.context, this.peer)
     }
     get isRethrowing(): boolean {
-        return global.generatedEs2panda._ETSFunctionTypeIrIsRethrowingConst(global.context, this.peer)
+        return global.generatedEs2panda._ETSFunctionTypeIsRethrowingConst(global.context, this.peer)
     }
     get isExtensionFunction(): boolean {
-        return global.generatedEs2panda._ETSFunctionTypeIrIsExtensionFunctionConst(global.context, this.peer)
+        return global.generatedEs2panda._ETSFunctionTypeIsExtensionFunctionConst(global.context, this.peer)
     }
 }
 export function isETSFunctionType(node: object | undefined): node is ETSFunctionType {
     return node instanceof ETSFunctionType
 }
-if (!nodeByType.has(66)) {
-    nodeByType.set(66, ETSFunctionType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, (peer: KNativePointer) => new ETSFunctionType(peer))
 }

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

@@ -22,47 +22,56 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
+import { Es2pandaId } from "./../Es2pandaEnums"
+import { Es2pandaImportFlags } from "./../Es2pandaEnums"
 import { Es2pandaImportKinds } from "./../Es2pandaEnums"
 import { ImportDeclaration } from "./ImportDeclaration"
-import { ImportSource } from "./ImportSource"
 import { StringLiteral } from "./StringLiteral"
 export class ETSImportDeclaration extends ImportDeclaration {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 78)
         super(pointer)
     }
-    static createETSImportDeclaration(source: ImportSource | undefined, specifiers: readonly AstNode[], importKind: Es2pandaImportKinds): ETSImportDeclaration {
-        return new ETSImportDeclaration(global.generatedEs2panda._CreateETSImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length, importKind))
+    static createETSImportDeclaration(importPath: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ETSImportDeclaration {
+        return new ETSImportDeclaration(global.generatedEs2panda._CreateETSImportDeclaration(global.context, passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds))
     }
-    static updateETSImportDeclaration(original: ETSImportDeclaration | undefined, source: ImportSource | undefined, specifiers: readonly AstNode[], importKind: Es2pandaImportKinds): ETSImportDeclaration {
-        return new ETSImportDeclaration(global.generatedEs2panda._UpdateETSImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length, importKind))
+    static updateETSImportDeclaration(original: ETSImportDeclaration | undefined, importPath: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ETSImportDeclaration {
+        return new ETSImportDeclaration(global.generatedEs2panda._UpdateETSImportDeclaration(global.context, passNode(original), passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds))
     }
-    get hasDecl(): boolean {
-        return global.generatedEs2panda._ETSImportDeclarationHasDeclConst(global.context, this.peer)
+    /** @deprecated */
+    setImportMetadata(importFlags: Es2pandaImportFlags, lang: Es2pandaId, resolvedSource: string, declPath: string, ohmUrl: string): this {
+        global.generatedEs2panda._ETSImportDeclarationSetImportMetadata(global.context, this.peer, importFlags, lang, resolvedSource, declPath, ohmUrl)
+        return this
+    }
+    get declPath(): string {
+        return unpackString(global.generatedEs2panda._ETSImportDeclarationDeclPathConst(global.context, this.peer))
+    }
+    get ohmUrl(): string {
+        return unpackString(global.generatedEs2panda._ETSImportDeclarationOhmUrlConst(global.context, this.peer))
+    }
+    get isValid(): boolean {
+        return global.generatedEs2panda._ETSImportDeclarationIsValidConst(global.context, this.peer)
     }
     get isPureDynamic(): boolean {
         return global.generatedEs2panda._ETSImportDeclarationIsPureDynamicConst(global.context, this.peer)
     }
     get assemblerName(): string {
-        return unpackString(global.generatedEs2panda._ETSImportDeclarationAssemblerNameConst(global.context, this.peer))
-    }
-    get source(): StringLiteral | undefined {
-        return unpackNode(global.generatedEs2panda._ETSImportDeclarationSourceConst(global.context, this.peer))
+        return unpackString(global.generatedEs2panda._ETSImportDeclarationAssemblerName(global.context, this.peer))
     }
-    get resolvedSource(): StringLiteral | undefined {
-        return unpackNode(global.generatedEs2panda._ETSImportDeclarationResolvedSourceConst(global.context, this.peer))
+    get resolvedSource(): string {
+        return unpackString(global.generatedEs2panda._ETSImportDeclarationResolvedSourceConst(global.context, this.peer))
     }
 }
 export function isETSImportDeclaration(node: object | undefined): node is ETSImportDeclaration {
     return node instanceof ETSImportDeclaration
 }
-if (!nodeByType.has(78)) {
-    nodeByType.set(78, ETSImportDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, (peer: KNativePointer) => new ETSImportDeclaration(peer))
 }

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

@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
+import { TypeNode } from "./TypeNode"
+export class ETSKeyofType extends TypeNode {
+    constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 74)
+        super(pointer)
+    }
+    static createETSKeyofType(type?: TypeNode): ETSKeyofType {
+        return new ETSKeyofType(global.generatedEs2panda._CreateETSKeyofType(global.context, passNode(type)))
+    }
+    static updateETSKeyofType(original?: ETSKeyofType, type?: TypeNode): ETSKeyofType {
+        return new ETSKeyofType(global.generatedEs2panda._UpdateETSKeyofType(global.context, passNode(original), passNode(type)))
+    }
+    get typeRef(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ETSKeyofTypeGetTypeRefConst(global.context, this.peer))
+    }
+}
+export function isETSKeyofType(node: object | undefined): node is ETSKeyofType {
+    return node instanceof ETSKeyofType
+}
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE, (peer: KNativePointer) => new ETSKeyofType(peer))
+}

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,14 +30,15 @@ import {
 
 import { AnnotationUsage } from "./AnnotationUsage"
 import { BlockStatement } from "./BlockStatement"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
 export class ETSModule extends BlockStatement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 81)
         super(pointer)
     }
     get ident(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ETSModuleIdentConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSModuleIdent(global.context, this.peer))
     }
     get isETSScript(): boolean {
         return global.generatedEs2panda._ETSModuleIsETSScriptConst(global.context, this.peer)
@@ -55,7 +55,7 @@ export class ETSModule extends BlockStatement {
         return this
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSModuleAnnotationsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSModuleAnnotations(global.context, this.peer))
     }
     /** @deprecated */
     setAnnotations(annotations: readonly AnnotationUsage[]): this {
@@ -66,6 +66,6 @@ export class ETSModule extends BlockStatement {
 export function isETSModule(node: object | undefined): node is ETSModule {
     return node instanceof ETSModule
 }
-if (!nodeByType.has(81)) {
-    nodeByType.set(81, ETSModule)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, (peer: KNativePointer) => new ETSModule(peer))
 }

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class ETSNewArrayInstanceExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 75)
         super(pointer)
     }
@@ -43,20 +43,25 @@ export class ETSNewArrayInstanceExpression extends Expression {
         return new ETSNewArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNode(dimension)))
     }
     get typeReference(): TypeNode | undefined {
-        return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionTypeReferenceConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionTypeReference(global.context, this.peer))
     }
     get dimension(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionDimensionConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionDimension(global.context, this.peer))
     }
     /** @deprecated */
     setDimension(dimension?: Expression): this {
         global.generatedEs2panda._ETSNewArrayInstanceExpressionSetDimension(global.context, this.peer, passNode(dimension))
         return this
     }
+    /** @deprecated */
+    clearPreferredType(): this {
+        global.generatedEs2panda._ETSNewArrayInstanceExpressionClearPreferredType(global.context, this.peer)
+        return this
+    }
 }
 export function isETSNewArrayInstanceExpression(node: object | undefined): node is ETSNewArrayInstanceExpression {
     return node instanceof ETSNewArrayInstanceExpression
 }
-if (!nodeByType.has(75)) {
-    nodeByType.set(75, ETSNewArrayInstanceExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewArrayInstanceExpression(peer))
 }

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class ETSNewClassInstanceExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 77)
         super(pointer)
     }
@@ -48,7 +48,7 @@ export class ETSNewClassInstanceExpression extends Expression {
         return unpackNode(global.generatedEs2panda._ETSNewClassInstanceExpressionGetTypeRefConst(global.context, this.peer))
     }
     get arguments(): readonly Expression[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSNewClassInstanceExpressionGetArgumentsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSNewClassInstanceExpressionGetArguments(global.context, this.peer))
     }
     /** @deprecated */
     setArguments(_arguments: readonly Expression[]): this {
@@ -64,6 +64,6 @@ export class ETSNewClassInstanceExpression extends Expression {
 export function isETSNewClassInstanceExpression(node: object | undefined): node is ETSNewClassInstanceExpression {
     return node instanceof ETSNewClassInstanceExpression
 }
-if (!nodeByType.has(77)) {
-    nodeByType.set(77, ETSNewClassInstanceExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewClassInstanceExpression(peer))
 }

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class ETSNewMultiDimArrayInstanceExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 76)
         super(pointer)
     }
@@ -46,15 +46,20 @@ export class ETSNewMultiDimArrayInstanceExpression extends Expression {
         return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(original), passNode(other)))
     }
     get typeReference(): TypeNode | undefined {
-        return unpackNode(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionTypeReferenceConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionTypeReference(global.context, this.peer))
     }
     get dimensions(): readonly Expression[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionDimensionsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionDimensions(global.context, this.peer))
+    }
+    /** @deprecated */
+    clearPreferredType(): this {
+        global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionClearPreferredType(global.context, this.peer)
+        return this
     }
 }
 export function isETSNewMultiDimArrayInstanceExpression(node: object | undefined): node is ETSNewMultiDimArrayInstanceExpression {
     return node instanceof ETSNewMultiDimArrayInstanceExpression
 }
-if (!nodeByType.has(76)) {
-    nodeByType.set(76, ETSNewMultiDimArrayInstanceExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewMultiDimArrayInstanceExpression(peer))
 }

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

@@ -22,29 +22,29 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class ETSNullType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 62)
         super(pointer)
     }
     static createETSNullType(): ETSNullType {
-        return new ETSNullType(global.generatedEs2panda._CreateETSNullTypeIr(global.context))
+        return new ETSNullType(global.generatedEs2panda._CreateETSNullType(global.context))
     }
     static updateETSNullType(original?: ETSNullType): ETSNullType {
-        return new ETSNullType(global.generatedEs2panda._UpdateETSNullTypeIr(global.context, passNode(original)))
+        return new ETSNullType(global.generatedEs2panda._UpdateETSNullType(global.context, passNode(original)))
     }
 }
 export function isETSNullType(node: object | undefined): node is ETSNullType {
     return node instanceof ETSNullType
 }
-if (!nodeByType.has(62)) {
-    nodeByType.set(62, ETSNullType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE, (peer: KNativePointer) => new ETSNullType(peer))
 }

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 export class ETSPackageDeclaration extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 69)
         super(pointer)
     }
@@ -46,6 +46,6 @@ export class ETSPackageDeclaration extends Statement {
 export function isETSPackageDeclaration(node: object | undefined): node is ETSPackageDeclaration {
     return node instanceof ETSPackageDeclaration
 }
-if (!nodeByType.has(69)) {
-    nodeByType.set(69, ETSPackageDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION, (peer: KNativePointer) => new ETSPackageDeclaration(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,12 +30,13 @@ import {
 
 import { AnnotatedExpression } from "./AnnotatedExpression"
 import { AnnotationUsage } from "./AnnotationUsage"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
 import { SpreadElement } from "./SpreadElement"
 import { TypeNode } from "./TypeNode"
 export class ETSParameterExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 79)
         super(pointer)
     }
@@ -55,8 +55,8 @@ export class ETSParameterExpression extends Expression {
     get name(): string {
         return unpackString(global.generatedEs2panda._ETSParameterExpressionNameConst(global.context, this.peer))
     }
-    get ident(): Identifier {
-        return unpackNonNullableNode(global.generatedEs2panda._ETSParameterExpressionIdentConst(global.context, this.peer))
+    get ident(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionIdent(global.context, this.peer))
     }
     /** @deprecated */
     setIdent(ident?: Identifier): this {
@@ -64,10 +64,10 @@ export class ETSParameterExpression extends Expression {
         return this
     }
     get restParameter(): SpreadElement | undefined {
-        return unpackNode(global.generatedEs2panda._ETSParameterExpressionRestParameterConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionRestParameter(global.context, this.peer))
     }
     get initializer(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._ETSParameterExpressionInitializerConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionInitializer(global.context, this.peer))
     }
     /** @deprecated */
     setLexerSaved(s: string): this {
@@ -78,7 +78,7 @@ export class ETSParameterExpression extends Expression {
         return unpackString(global.generatedEs2panda._ETSParameterExpressionLexerSavedConst(global.context, this.peer))
     }
     get typeAnnotation(): TypeNode | undefined {
-        return unpackNode(global.generatedEs2panda._ETSParameterExpressionTypeAnnotationConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionTypeAnnotation(global.context, this.peer))
     }
     /** @deprecated */
     setTypeAnnotation(typeNode?: TypeNode): this {
@@ -110,7 +110,7 @@ export class ETSParameterExpression extends Expression {
         return this
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSParameterExpressionAnnotationsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSParameterExpressionAnnotations(global.context, this.peer))
     }
     /** @deprecated */
     setAnnotations(annotations: readonly AnnotationUsage[]): this {
@@ -121,6 +121,6 @@ export class ETSParameterExpression extends Expression {
 export function isETSParameterExpression(node: object | undefined): node is ETSParameterExpression {
     return node instanceof ETSParameterExpression
 }
-if (!nodeByType.has(79)) {
-    nodeByType.set(79, ETSParameterExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, (peer: KNativePointer) => new ETSParameterExpression(peer))
 }

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaPrimitiveType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class ETSPrimitiveType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 68)
         super(pointer)
     }
@@ -49,6 +49,6 @@ export class ETSPrimitiveType extends TypeNode {
 export function isETSPrimitiveType(node: object | undefined): node is ETSPrimitiveType {
     return node instanceof ETSPrimitiveType
 }
-if (!nodeByType.has(68)) {
-    nodeByType.set(68, ETSPrimitiveType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, (peer: KNativePointer) => new ETSPrimitiveType(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,14 +29,15 @@ import {
 } from "../../reexport-for-generated"
 
 import { ETSImportDeclaration } from "./ETSImportDeclaration"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 export class ETSReExportDeclaration extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 57)
         super(pointer)
     }
     get eTSImportDeclarations(): ETSImportDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._ETSReExportDeclarationGetETSImportDeclarationsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSReExportDeclarationGetETSImportDeclarations(global.context, this.peer))
     }
     get programPath(): string {
         return unpackString(global.generatedEs2panda._ETSReExportDeclarationGetProgramPathConst(global.context, this.peer))
@@ -46,6 +46,6 @@ export class ETSReExportDeclaration extends Statement {
 export function isETSReExportDeclaration(node: object | undefined): node is ETSReExportDeclaration {
     return node instanceof ETSReExportDeclaration
 }
-if (!nodeByType.has(57)) {
-    nodeByType.set(57, ETSReExportDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_REEXPORT_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_REEXPORT_STATEMENT, (peer: KNativePointer) => new ETSReExportDeclaration(peer))
 }