@idlizer/arktscgen 2.1.2 → 2.1.7

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

@@ -22,18 +22,18 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaPropertyKind } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { ValidationInfo } from "./ValidationInfo"
 export class Property extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 55)
         super(pointer)
     }
@@ -47,10 +47,10 @@ export class Property extends Expression {
         return new Property(global.generatedEs2panda._UpdateProperty1(global.context, passNode(original), kind, passNode(key), passNode(value), isMethod, isComputed))
     }
     get key(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._PropertyKeyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._PropertyKey(global.context, this.peer))
     }
     get value(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._PropertyValueConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._PropertyValue(global.context, this.peer))
     }
     get kind(): Es2pandaPropertyKind {
         return global.generatedEs2panda._PropertyKindConst(global.context, this.peer)
@@ -77,6 +77,6 @@ export class Property extends Expression {
 export function isProperty(node: object | undefined): node is Property {
     return node instanceof Property
 }
-if (!nodeByType.has(55)) {
-    nodeByType.set(55, Property)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY, (peer: KNativePointer) => new Property(peer))
 }

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaRegExpFlags } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 export class RegExpLiteral extends Literal {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 56)
         super(pointer)
     }
@@ -52,6 +52,6 @@ export class RegExpLiteral extends Literal {
 export function isRegExpLiteral(node: object | undefined): node is RegExpLiteral {
     return node instanceof RegExpLiteral
 }
-if (!nodeByType.has(56)) {
-    nodeByType.set(56, RegExpLiteral)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL, (peer: KNativePointer) => new RegExpLiteral(peer))
 }

package/build/libarkts-copy/src/generated/peers/ReturnStatement.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 ReturnStatement extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 58)
         super(pointer)
     }
@@ -46,17 +46,20 @@ export class ReturnStatement extends Statement {
         return new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument)))
     }
     get argument(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._ReturnStatementArgumentConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ReturnStatementArgument(global.context, this.peer))
     }
     /** @deprecated */
     setArgument(arg?: Expression): this {
         global.generatedEs2panda._ReturnStatementSetArgument(global.context, this.peer, passNode(arg))
         return this
     }
+    get isAsyncImplReturn(): boolean {
+        return global.generatedEs2panda._ReturnStatementIsAsyncImplReturnConst(global.context, this.peer)
+    }
 }
 export function isReturnStatement(node: object | undefined): node is ReturnStatement {
     return node instanceof ReturnStatement
 }
-if (!nodeByType.has(58)) {
-    nodeByType.set(58, ReturnStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, (peer: KNativePointer) => new ReturnStatement(peer))
 }

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

@@ -0,0 +1,35 @@
+/*
+ * 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"
+
+export class ScopeFindResult extends ArktsObject {
+    constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,6 +29,7 @@ import {
 } from "../../reexport-for-generated"
 
 import { AnnotationUsage } from "./AnnotationUsage"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Es2pandaScriptFunctionFlags } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
@@ -39,7 +39,7 @@ import { ReturnStatement } from "./ReturnStatement"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 export class ScriptFunction extends AstNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 59)
         super(pointer)
     }
@@ -50,19 +50,19 @@ export class ScriptFunction extends AstNode {
         return new ScriptFunction(global.generatedEs2panda._UpdateScriptFunction(global.context, passNode(original), passNode(databody), passNode(datasignature), datafuncFlags, dataflags))
     }
     get id(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ScriptFunctionIdConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ScriptFunctionId(global.context, this.peer))
     }
     get params(): readonly Expression[] {
-        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionParamsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionParams(global.context, this.peer))
     }
     get returnStatements(): readonly ReturnStatement[] {
-        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionReturnStatementsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionReturnStatements(global.context, this.peer))
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._ScriptFunctionTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ScriptFunctionTypeParams(global.context, this.peer))
     }
     get body(): AstNode | undefined {
-        return unpackNode(global.generatedEs2panda._ScriptFunctionBodyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ScriptFunctionBody(global.context, this.peer))
     }
     /** @deprecated */
     addReturnStatement(returnStatement?: ReturnStatement): this {
@@ -75,7 +75,7 @@ export class ScriptFunction extends AstNode {
         return this
     }
     get returnTypeAnnotation(): TypeNode | undefined {
-        return unpackNode(global.generatedEs2panda._ScriptFunctionReturnTypeAnnotationConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ScriptFunctionReturnTypeAnnotation(global.context, this.peer))
     }
     /** @deprecated */
     setReturnTypeAnnotation(node?: TypeNode): this {
@@ -177,6 +177,11 @@ export class ScriptFunction extends AstNode {
         return this
     }
     /** @deprecated */
+    clearFlag(flags: Es2pandaScriptFunctionFlags): this {
+        global.generatedEs2panda._ScriptFunctionClearFlag(global.context, this.peer, flags)
+        return this
+    }
+    /** @deprecated */
     addModifier(flags: Es2pandaModifierFlags): this {
         global.generatedEs2panda._ScriptFunctionAddModifier(global.context, this.peer, flags)
         return this
@@ -185,7 +190,7 @@ export class ScriptFunction extends AstNode {
         return global.generatedEs2panda._ScriptFunctionFormalParamsLengthConst(global.context, this.peer)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionAnnotationsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionAnnotations(global.context, this.peer))
     }
     /** @deprecated */
     setAnnotations(annotations: readonly AnnotationUsage[]): this {
@@ -196,6 +201,6 @@ export class ScriptFunction extends AstNode {
 export function isScriptFunction(node: object | undefined): node is ScriptFunction {
     return node instanceof ScriptFunction
 }
-if (!nodeByType.has(59)) {
-    nodeByType.set(59, ScriptFunction)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, (peer: KNativePointer) => new ScriptFunction(peer))
 }

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

@@ -0,0 +1,35 @@
+/*
+ * 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"
+
+export class ScriptFunctionData extends ArktsObject {
+    constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}

package/build/libarkts-copy/src/generated/peers/SequenceExpression.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 SequenceExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 60)
         super(pointer)
     }
@@ -42,12 +42,12 @@ export class SequenceExpression extends Expression {
         return new SequenceExpression(global.generatedEs2panda._UpdateSequenceExpression(global.context, passNode(original), passNodeArray(sequence_arg), sequence_arg.length))
     }
     get sequence(): readonly Expression[] {
-        return unpackNodeArray(global.generatedEs2panda._SequenceExpressionSequenceConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._SequenceExpressionSequence(global.context, this.peer))
     }
 }
 export function isSequenceExpression(node: object | undefined): node is SequenceExpression {
     return node instanceof SequenceExpression
 }
-if (!nodeByType.has(60)) {
-    nodeByType.set(60, SequenceExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION, (peer: KNativePointer) => new SequenceExpression(peer))
 }

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

@@ -0,0 +1,35 @@
+/*
+ * 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"
+
+export class SignatureInfo extends ArktsObject {
+    constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}

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

@@ -0,0 +1,35 @@
+/*
+ * 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"
+
+export class SourcePosition extends ArktsObject {
+    constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}

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

@@ -0,0 +1,35 @@
+/*
+ * 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"
+
+export class SourceRange extends ArktsObject {
+    constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,11 +30,12 @@ import {
 
 import { AnnotatedExpression } from "./AnnotatedExpression"
 import { Decorator } from "./Decorator"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 import { ValidationInfo } from "./ValidationInfo"
 export class SpreadElement extends AnnotatedExpression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 162)
         super(pointer)
     }
@@ -46,7 +46,7 @@ export class SpreadElement extends AnnotatedExpression {
         return new SpreadElement(global.generatedEs2panda._UpdateSpreadElement(global.context, passNode(original), nodeType, passNode(argument)))
     }
     get argument(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._SpreadElementArgumentConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._SpreadElementArgument(global.context, this.peer))
     }
     get isOptional(): boolean {
         return global.generatedEs2panda._SpreadElementIsOptionalConst(global.context, this.peer)
@@ -74,6 +74,6 @@ export class SpreadElement extends AnnotatedExpression {
 export function isSpreadElement(node: object | undefined): node is SpreadElement {
     return node instanceof SpreadElement
 }
-if (!nodeByType.has(162)) {
-    nodeByType.set(162, SpreadElement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT, (peer: KNativePointer) => new SpreadElement(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,7 +29,7 @@ import {
 } from "../../reexport-for-generated"
 
 export class SrcDumper extends ArktsObject {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
     static createSrcDumper(node?: AstNode): SrcDumper {

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,7 +29,7 @@ import {
 } from "../../reexport-for-generated"
 
 export class Statement extends AstNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
 }

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 export class StringLiteral extends Literal {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 61)
         super(pointer)
     }
@@ -51,6 +51,6 @@ export class StringLiteral extends Literal {
 export function isStringLiteral(node: object | undefined): node is StringLiteral {
     return node instanceof StringLiteral
 }
-if (!nodeByType.has(61)) {
-    nodeByType.set(61, StringLiteral)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, (peer: KNativePointer) => new StringLiteral(peer))
 }

package/build/libarkts-copy/src/generated/peers/SuperExpression.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 SuperExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 82)
         super(pointer)
     }
@@ -45,6 +45,6 @@ export class SuperExpression extends Expression {
 export function isSuperExpression(node: object | undefined): node is SuperExpression {
     return node instanceof SuperExpression
 }
-if (!nodeByType.has(82)) {
-    nodeByType.set(82, SuperExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, (peer: KNativePointer) => new SuperExpression(peer))
 }

package/build/libarkts-copy/src/generated/peers/SwitchCaseStatement.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 SwitchCaseStatement extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 84)
         super(pointer)
     }
@@ -43,7 +43,7 @@ export class SwitchCaseStatement extends Statement {
         return new SwitchCaseStatement(global.generatedEs2panda._UpdateSwitchCaseStatement(global.context, passNode(original), passNode(test), passNodeArray(consequent), consequent.length))
     }
     get test(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._SwitchCaseStatementTestConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._SwitchCaseStatementTest(global.context, this.peer))
     }
     /** @deprecated */
     setTest(test?: Expression): this {
@@ -57,6 +57,6 @@ export class SwitchCaseStatement extends Statement {
 export function isSwitchCaseStatement(node: object | undefined): node is SwitchCaseStatement {
     return node instanceof SwitchCaseStatement
 }
-if (!nodeByType.has(84)) {
-    nodeByType.set(84, SwitchCaseStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT, (peer: KNativePointer) => new SwitchCaseStatement(peer))
 }

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

@@ -22,18 +22,18 @@ 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"
 import { SwitchCaseStatement } from "./SwitchCaseStatement"
 export class SwitchStatement extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 85)
         super(pointer)
     }
@@ -44,7 +44,7 @@ export class SwitchStatement extends Statement {
         return new SwitchStatement(global.generatedEs2panda._UpdateSwitchStatement(global.context, passNode(original), passNode(discriminant), passNodeArray(cases), cases.length))
     }
     get discriminant(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._SwitchStatementDiscriminantConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._SwitchStatementDiscriminant(global.context, this.peer))
     }
     /** @deprecated */
     setDiscriminant(discriminant?: Expression): this {
@@ -52,12 +52,12 @@ export class SwitchStatement extends Statement {
         return this
     }
     get cases(): readonly SwitchCaseStatement[] {
-        return unpackNodeArray(global.generatedEs2panda._SwitchStatementCasesConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._SwitchStatementCases(global.context, this.peer))
     }
 }
 export function isSwitchStatement(node: object | undefined): node is SwitchStatement {
     return node instanceof SwitchStatement
 }
-if (!nodeByType.has(85)) {
-    nodeByType.set(85, SwitchStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT, (peer: KNativePointer) => new SwitchStatement(peer))
 }

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class TSAnyKeyword extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 90)
         super(pointer)
     }
@@ -45,6 +45,6 @@ export class TSAnyKeyword extends TypeNode {
 export function isTSAnyKeyword(node: object | undefined): node is TSAnyKeyword {
     return node instanceof TSAnyKeyword
 }
-if (!nodeByType.has(90)) {
-    nodeByType.set(90, TSAnyKeyword)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD, (peer: KNativePointer) => new TSAnyKeyword(peer))
 }