@idlizer/arktscgen 2.1.2 → 2.1.7

package/build/libarkts-copy/src/generated/peers/AstVisitor.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 AstVisitor extends ArktsObject {
+    constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}

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

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

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

@@ -22,17 +22,19 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { CodeGen } from "./CodeGen"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaTokenType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
+import { VReg } from "./VReg"
 export class BinaryExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 6)
         super(pointer)
     }
@@ -43,13 +45,13 @@ export class BinaryExpression extends Expression {
         return new BinaryExpression(global.generatedEs2panda._UpdateBinaryExpression(global.context, passNode(original), passNode(left), passNode(right), operatorType))
     }
     get left(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._BinaryExpressionLeftConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._BinaryExpressionLeft(global.context, this.peer))
     }
     get right(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._BinaryExpressionRightConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._BinaryExpressionRight(global.context, this.peer))
     }
     get result(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._BinaryExpressionResultConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._BinaryExpressionResult(global.context, this.peer))
     }
     get operatorType(): Es2pandaTokenType {
         return global.generatedEs2panda._BinaryExpressionOperatorTypeConst(global.context, this.peer)
@@ -86,10 +88,15 @@ export class BinaryExpression extends Expression {
         global.generatedEs2panda._BinaryExpressionSetOperator(global.context, this.peer, operatorType)
         return this
     }
+    /** @deprecated */
+    compileOperands(etsg?: CodeGen, lhs?: VReg): this {
+        global.generatedEs2panda._BinaryExpressionCompileOperandsConst(global.context, this.peer, passNode(etsg), passNode(lhs))
+        return this
+    }
 }
 export function isBinaryExpression(node: object | undefined): node is BinaryExpression {
     return node instanceof BinaryExpression
 }
-if (!nodeByType.has(6)) {
-    nodeByType.set(6, BinaryExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, (peer: KNativePointer) => new BinaryExpression(peer))
 }

package/build/libarkts-copy/src/generated/peers/BindingProps.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 BindingProps extends ArktsObject {
+    constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}

package/build/libarkts-copy/src/generated/peers/BlockExpression.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 BlockExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 154)
         super(pointer)
     }
@@ -43,7 +43,7 @@ export class BlockExpression extends Expression {
         return new BlockExpression(global.generatedEs2panda._UpdateBlockExpression(global.context, passNode(original), passNodeArray(statements), statements.length))
     }
     get statements(): readonly Statement[] {
-        return unpackNodeArray(global.generatedEs2panda._BlockExpressionStatementsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._BlockExpressionStatements(global.context, this.peer))
     }
     /** @deprecated */
     addStatements(statements: readonly Statement[]): this {
@@ -59,6 +59,6 @@ export class BlockExpression extends Expression {
 export function isBlockExpression(node: object | undefined): node is BlockExpression {
     return node instanceof BlockExpression
 }
-if (!nodeByType.has(154)) {
-    nodeByType.set(154, BlockExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION, (peer: KNativePointer) => new BlockExpression(peer))
 }

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 export class BlockStatement extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 7)
         super(pointer)
     }
@@ -42,7 +42,7 @@ export class BlockStatement extends Statement {
         return new BlockStatement(global.generatedEs2panda._UpdateBlockStatement(global.context, passNode(original), passNodeArray(statementList), statementList.length))
     }
     get statements(): readonly Statement[] {
-        return unpackNodeArray(global.generatedEs2panda._BlockStatementStatementsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._BlockStatementStatements(global.context, this.peer))
     }
     /** @deprecated */
     setStatements(statementList: readonly Statement[]): this {
@@ -50,6 +50,16 @@ export class BlockStatement extends Statement {
         return this
     }
     /** @deprecated */
+    addStatement(stmt?: Statement): this {
+        global.generatedEs2panda._BlockStatementAddStatement(global.context, this.peer, passNode(stmt))
+        return this
+    }
+    /** @deprecated */
+    addStatements(stmts: readonly Statement[]): this {
+        global.generatedEs2panda._BlockStatementAddStatements(global.context, this.peer, passNodeArray(stmts), stmts.length)
+        return this
+    }
+    /** @deprecated */
     addTrailingBlock(stmt?: AstNode, trailingBlock?: BlockStatement): this {
         global.generatedEs2panda._BlockStatementAddTrailingBlock(global.context, this.peer, passNode(stmt), passNode(trailingBlock))
         return this
@@ -58,6 +68,6 @@ export class BlockStatement extends Statement {
 export function isBlockStatement(node: object | undefined): node is BlockStatement {
     return node instanceof BlockStatement
 }
-if (!nodeByType.has(7)) {
-    nodeByType.set(7, BlockStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, (peer: KNativePointer) => new BlockStatement(peer))
 }

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

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 export class BreakStatement extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 9)
         super(pointer)
     }
@@ -46,11 +46,14 @@ export class BreakStatement extends Statement {
         return new BreakStatement(global.generatedEs2panda._UpdateBreakStatement1(global.context, passNode(original), passNode(ident)))
     }
     get ident(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._BreakStatementIdentConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._BreakStatementIdent(global.context, this.peer))
     }
     get target(): AstNode | undefined {
         return unpackNode(global.generatedEs2panda._BreakStatementTargetConst(global.context, this.peer))
     }
+    get hasTarget(): boolean {
+        return global.generatedEs2panda._BreakStatementHasTargetConst(global.context, this.peer)
+    }
     /** @deprecated */
     setTarget(target?: AstNode): this {
         global.generatedEs2panda._BreakStatementSetTarget(global.context, this.peer, passNode(target))
@@ -60,6 +63,6 @@ export class BreakStatement extends Statement {
 export function isBreakStatement(node: object | undefined): node is BreakStatement {
     return node instanceof BreakStatement
 }
-if (!nodeByType.has(9)) {
-    nodeByType.set(9, BreakStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT, (peer: KNativePointer) => new BreakStatement(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,11 +29,12 @@ import {
 } from "../../reexport-for-generated"
 
 import { BlockStatement } from "./BlockStatement"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { MaybeOptionalExpression } from "./MaybeOptionalExpression"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 export class CallExpression extends MaybeOptionalExpression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 10)
         super(pointer)
     }
@@ -44,8 +44,8 @@ export class CallExpression extends MaybeOptionalExpression {
     static update1CallExpression(original?: CallExpression, other?: CallExpression): CallExpression {
         return new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other)))
     }
-    get callee(): Expression {
-        return unpackNonNullableNode(global.generatedEs2panda._CallExpressionCalleeConst(global.context, this.peer))
+    get callee(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._CallExpressionCallee(global.context, this.peer))
     }
     /** @deprecated */
     setCallee(callee?: Expression): this {
@@ -53,10 +53,10 @@ export class CallExpression extends MaybeOptionalExpression {
         return this
     }
     get typeParams(): TSTypeParameterInstantiation | undefined {
-        return unpackNode(global.generatedEs2panda._CallExpressionTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._CallExpressionTypeParams(global.context, this.peer))
     }
     get arguments(): readonly Expression[] {
-        return unpackNodeArray(global.generatedEs2panda._CallExpressionArgumentsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._CallExpressionArguments(global.context, this.peer))
     }
     get hasTrailingComma(): boolean {
         return global.generatedEs2panda._CallExpressionHasTrailingCommaConst(global.context, this.peer)
@@ -92,6 +92,6 @@ export class CallExpression extends MaybeOptionalExpression {
 export function isCallExpression(node: object | undefined): node is CallExpression {
     return node instanceof CallExpression
 }
-if (!nodeByType.has(10)) {
-    nodeByType.set(10, CallExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, (peer: KNativePointer) => new CallExpression(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,10 +29,11 @@ import {
 } from "../../reexport-for-generated"
 
 import { BlockStatement } from "./BlockStatement"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypedStatement } from "./TypedStatement"
 export class CatchClause extends TypedStatement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 11)
         super(pointer)
     }
@@ -47,10 +47,10 @@ export class CatchClause extends TypedStatement {
         return new CatchClause(global.generatedEs2panda._UpdateCatchClause1(global.context, passNode(original), passNode(other)))
     }
     get param(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._CatchClauseParamConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._CatchClauseParam(global.context, this.peer))
     }
     get body(): BlockStatement | undefined {
-        return unpackNode(global.generatedEs2panda._CatchClauseBodyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._CatchClauseBody(global.context, this.peer))
     }
     get isDefaultCatchClause(): boolean {
         return global.generatedEs2panda._CatchClauseIsDefaultCatchClauseConst(global.context, this.peer)
@@ -59,6 +59,6 @@ export class CatchClause extends TypedStatement {
 export function isCatchClause(node: object | undefined): node is CatchClause {
     return node instanceof CatchClause
 }
-if (!nodeByType.has(11)) {
-    nodeByType.set(11, CatchClause)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE, (peer: KNativePointer) => new CatchClause(peer))
 }

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

@@ -22,16 +22,18 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { CodeGen } from "./CodeGen"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
+import { VReg } from "./VReg"
 export class ChainExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 12)
         super(pointer)
     }
@@ -42,12 +44,17 @@ export class ChainExpression extends Expression {
         return new ChainExpression(global.generatedEs2panda._UpdateChainExpression(global.context, passNode(original), passNode(expression)))
     }
     get expression(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._ChainExpressionGetExpressionConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ChainExpressionGetExpression(global.context, this.peer))
+    }
+    /** @deprecated */
+    compileToReg(pg?: CodeGen, objReg?: VReg): this {
+        global.generatedEs2panda._ChainExpressionCompileToRegConst(global.context, this.peer, passNode(pg), passNode(objReg))
+        return this
     }
 }
 export function isChainExpression(node: object | undefined): node is ChainExpression {
     return node instanceof ChainExpression
 }
-if (!nodeByType.has(12)) {
-    nodeByType.set(12, ChainExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION, (peer: KNativePointer) => new ChainExpression(peer))
 }

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

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,9 +30,10 @@ import {
 
 import { ClassDefinition } from "./ClassDefinition"
 import { Decorator } from "./Decorator"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 export class ClassDeclaration extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 15)
         super(pointer)
     }
@@ -44,7 +44,7 @@ export class ClassDeclaration extends Statement {
         return new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def)))
     }
     get definition(): ClassDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._ClassDeclarationDefinitionConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassDeclarationDefinition(global.context, this.peer))
     }
     get decorators(): readonly Decorator[] {
         return unpackNodeArray(global.generatedEs2panda._ClassDeclarationDecoratorsConst(global.context, this.peer))
@@ -53,6 +53,6 @@ export class ClassDeclaration extends Statement {
 export function isClassDeclaration(node: object | undefined): node is ClassDeclaration {
     return node instanceof ClassDeclaration
 }
-if (!nodeByType.has(15)) {
-    nodeByType.set(15, ClassDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, (peer: KNativePointer) => new ClassDeclaration(peer))
 }