@idlizer/arktscgen 2.1.9-arktscgen-9 → 2.1.10-arktscgen-3

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -39,20 +38,21 @@ import { Expression } from "./Expression"
 import { FunctionSignature } from "./FunctionSignature"
 import { Identifier } from "./Identifier"
 import { ReturnStatement } from "./ReturnStatement"
+import { SrcDumper } from "./SrcDumper"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
+import { extension_ScriptFunctionGetParamsCasted } from "./../../reexport-for-generated"
 import { extension_ScriptFunctionGetPreferredReturnTypePointer } from "./../../reexport-for-generated"
 import { extension_ScriptFunctionGetSignaturePointer } from "./../../reexport-for-generated"
 import { extension_ScriptFunctionSetPreferredReturnTypePointer } from "./../../reexport-for-generated"
 import { extension_ScriptFunctionSetSignaturePointer } from "./../../reexport-for-generated"
 
 export class ScriptFunction extends AstNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 60)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     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))
+        const result: ScriptFunction = new ScriptFunction(global.generatedEs2panda._CreateScriptFunction(global.context, passNode(databody), passNode(datasignature), datafuncFlags, dataflags), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)
         if (ident)
         {
             result.setIdent(ident)
@@ -65,7 +65,7 @@ export class ScriptFunction extends AstNode {
         return result
     }
     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))
+        const result: ScriptFunction = new ScriptFunction(global.generatedEs2panda._UpdateScriptFunction(global.context, passNode(original), passNode(databody), passNode(datasignature), datafuncFlags, dataflags), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)
         if (ident)
         {
             result.setIdent(ident)
@@ -78,19 +78,19 @@ export class ScriptFunction extends AstNode {
         return result
     }
     get id(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ScriptFunctionId(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ScriptFunctionId(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get params(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._ScriptFunctionParams(global.context, this.peer))
     }
     get returnStatements(): readonly ReturnStatement[] {
-        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionReturnStatements(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionReturnStatements(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
     }
     get returnStatementsForUpdate(): readonly ReturnStatement[] {
-        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionReturnStatementsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionReturnStatementsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._ScriptFunctionTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ScriptFunctionTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
     }
     get body(): AstNode | undefined {
         return unpackNode(global.generatedEs2panda._ScriptFunctionBody(global.context, this.peer))
@@ -221,7 +221,7 @@ export class ScriptFunction extends AstNode {
         return this
     }
     get asyncPairMethod(): ScriptFunction | undefined {
-        return unpackNode(global.generatedEs2panda._ScriptFunctionAsyncPairMethod(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ScriptFunctionAsyncPairMethod(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)
     }
     /** @deprecated */
     emplaceReturnStatements(returnStatements?: ReturnStatement): this {
@@ -244,6 +244,11 @@ export class ScriptFunction extends AstNode {
         return this
     }
     /** @deprecated */
+    setParams(paramsList: readonly Expression[]): this {
+        global.generatedEs2panda._ScriptFunctionSetParams(global.context, this.peer, passNodeArray(paramsList), paramsList.length)
+        return this
+    }
+    /** @deprecated */
     clearParams(): this {
         global.generatedEs2panda._ScriptFunctionClearParams(global.context, this.peer)
         return this
@@ -256,9 +261,12 @@ export class ScriptFunction extends AstNode {
     get paramsForUpdate(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._ScriptFunctionParamsForUpdate(global.context, this.peer))
     }
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._ScriptFunctionHasAnnotationsConst(global.context, this.peer)
+    }
     /** @deprecated */
-    emplaceAnnotations(source?: AnnotationUsage): this {
-        global.generatedEs2panda._ScriptFunctionEmplaceAnnotations(global.context, this.peer, passNode(source))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._ScriptFunctionEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -267,15 +275,15 @@ export class ScriptFunction extends AstNode {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(source: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._ScriptFunctionSetValueAnnotations(global.context, this.peer, passNode(source), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._ScriptFunctionDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionAnnotations(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
     setAnnotations(annotationList: readonly AnnotationUsage[]): this {
@@ -287,13 +295,9 @@ export class ScriptFunction extends AstNode {
         global.generatedEs2panda._ScriptFunctionSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    /** @deprecated */
-    addAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._ScriptFunctionAddAnnotations(global.context, this.peer, passNode(annotations))
-        return this
-    }
     getSignaturePointer = extension_ScriptFunctionGetSignaturePointer
     setSignaturePointer = extension_ScriptFunctionSetSignaturePointer
+    getParamsCasted = extension_ScriptFunctionGetParamsCasted
     getPreferredReturnTypePointer = extension_ScriptFunctionGetPreferredReturnTypePointer
     setPreferredReturnTypePointer = extension_ScriptFunctionSetPreferredReturnTypePointer
     protected readonly brandScriptFunction: undefined
@@ -302,5 +306,5 @@ export function isScriptFunction(node: object | undefined): node is ScriptFuncti
     return node instanceof ScriptFunction
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, (peer: KNativePointer) => new ScriptFunction(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, (peer: KNativePointer) => new ScriptFunction(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class SequenceExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 61)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createSequenceExpression(sequence_arg: readonly Expression[]): SequenceExpression {
-        const result: SequenceExpression = new SequenceExpression(global.generatedEs2panda._CreateSequenceExpression(global.context, passNodeArray(sequence_arg), sequence_arg.length))
+        const result: SequenceExpression = new SequenceExpression(global.generatedEs2panda._CreateSequenceExpression(global.context, passNodeArray(sequence_arg), sequence_arg.length), Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateSequenceExpression(original: SequenceExpression | undefined, sequence_arg: readonly Expression[]): SequenceExpression {
-        const result: SequenceExpression = new SequenceExpression(global.generatedEs2panda._UpdateSequenceExpression(global.context, passNode(original), passNodeArray(sequence_arg), sequence_arg.length))
+        const result: SequenceExpression = new SequenceExpression(global.generatedEs2panda._UpdateSequenceExpression(global.context, passNode(original), passNodeArray(sequence_arg), sequence_arg.length), Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isSequenceExpression(node: object | undefined): node is Sequence
     return node instanceof SequenceExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION, (peer: KNativePointer) => new SequenceExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION, (peer: KNativePointer) => new SequenceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -32,10 +31,18 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { extension_SourcePositionGetCol } from "./../../reexport-for-generated"
+import { extension_SourcePositionGetIndex } from "./../../reexport-for-generated"
+import { extension_SourcePositionGetLine } from "./../../reexport-for-generated"
+import { extension_SourcePositionToString } from "./../../reexport-for-generated"
 
 export class SourcePosition extends ArktsObject {
     constructor(pointer: KNativePointer) {
         super(pointer)
     }
+    getLine = extension_SourcePositionGetLine
+    getCol = extension_SourcePositionGetCol
+    getIndex = extension_SourcePositionGetIndex
+    toString = extension_SourcePositionToString
     protected readonly brandSourcePosition: undefined
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -33,24 +32,22 @@ import {
 } from "../../reexport-for-generated"
 
 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) {
-        assertValidPeer(pointer, 165)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createSpreadElement(nodeType: Es2pandaAstNodeType, argument?: Expression): SpreadElement {
-        const result: SpreadElement = new SpreadElement(global.generatedEs2panda._CreateSpreadElement(global.context, nodeType, passNode(argument)))
+        const result: SpreadElement = new SpreadElement(global.generatedEs2panda._CreateSpreadElement(global.context, nodeType, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateSpreadElement(original: SpreadElement | undefined, nodeType: Es2pandaAstNodeType, argument?: Expression): SpreadElement {
-        const result: SpreadElement = new SpreadElement(global.generatedEs2panda._UpdateSpreadElement(global.context, passNode(original), nodeType, passNode(argument)))
+        const result: SpreadElement = new SpreadElement(global.generatedEs2panda._UpdateSpreadElement(global.context, passNode(original), nodeType, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,9 +57,6 @@ export class SpreadElement extends AnnotatedExpression {
     get isOptional(): boolean {
         return global.generatedEs2panda._SpreadElementIsOptionalConst(global.context, this.peer)
     }
-    get decorators(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._SpreadElementDecoratorsConst(global.context, this.peer))
-    }
     /** @deprecated */
     setOptional(optional_arg: boolean): this {
         global.generatedEs2panda._SpreadElementSetOptional(global.context, this.peer, optional_arg)
@@ -85,5 +79,5 @@ export function isSpreadElement(node: object | undefined): node is SpreadElement
     return node instanceof SpreadElement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT, (peer: KNativePointer) => new SpreadElement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT, (peer: KNativePointer) => new SpreadElement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -116,3 +115,6 @@ export class SrcDumper extends ArktsObject {
     }
     protected readonly brandSrcDumper: undefined
 }
+export function isSrcDumper(node: object | undefined): node is SrcDumper {
+    return node instanceof SrcDumper
+}

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -32,10 +31,11 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 
 export class Statement extends AstNode {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     protected readonly brandStatement: undefined
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,22 +35,21 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 
 export class StringLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 62)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1StringLiteral(str: string): StringLiteral {
-        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._CreateStringLiteral1(global.context, str))
+        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._CreateStringLiteral1(global.context, str), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateStringLiteral(original?: StringLiteral): StringLiteral {
-        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._UpdateStringLiteral(global.context, passNode(original)))
+        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._UpdateStringLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static update1StringLiteral(original: StringLiteral | undefined, str: string): StringLiteral {
-        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._UpdateStringLiteral1(global.context, passNode(original), str))
+        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._UpdateStringLiteral1(global.context, passNode(original), str), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -64,5 +62,5 @@ export function isStringLiteral(node: object | undefined): node is StringLiteral
     return node instanceof StringLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, (peer: KNativePointer) => new StringLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, (peer: KNativePointer) => new StringLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class SuperExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 85)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createSuperExpression(): SuperExpression {
-        const result: SuperExpression = new SuperExpression(global.generatedEs2panda._CreateSuperExpression(global.context))
+        const result: SuperExpression = new SuperExpression(global.generatedEs2panda._CreateSuperExpression(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateSuperExpression(original?: SuperExpression): SuperExpression {
-        const result: SuperExpression = new SuperExpression(global.generatedEs2panda._UpdateSuperExpression(global.context, passNode(original)))
+        const result: SuperExpression = new SuperExpression(global.generatedEs2panda._UpdateSuperExpression(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isSuperExpression(node: object | undefined): node is SuperExpres
     return node instanceof SuperExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, (peer: KNativePointer) => new SuperExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, (peer: KNativePointer) => new SuperExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class SwitchCaseStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 87)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createSwitchCaseStatement(test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement {
-        const result: SwitchCaseStatement = new SwitchCaseStatement(global.generatedEs2panda._CreateSwitchCaseStatement(global.context, passNode(test), passNodeArray(consequent), consequent.length))
+        const result: SwitchCaseStatement = new SwitchCaseStatement(global.generatedEs2panda._CreateSwitchCaseStatement(global.context, passNode(test), passNodeArray(consequent), consequent.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateSwitchCaseStatement(original: SwitchCaseStatement | undefined, test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement {
-        const result: SwitchCaseStatement = new SwitchCaseStatement(global.generatedEs2panda._UpdateSwitchCaseStatement(global.context, passNode(original), passNode(test), passNodeArray(consequent), consequent.length))
+        const result: SwitchCaseStatement = new SwitchCaseStatement(global.generatedEs2panda._UpdateSwitchCaseStatement(global.context, passNode(original), passNode(test), passNodeArray(consequent), consequent.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -68,5 +66,5 @@ export function isSwitchCaseStatement(node: object | undefined): node is SwitchC
     return node instanceof 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))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT, (peer: KNativePointer) => new SwitchCaseStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,17 +37,16 @@ import { Statement } from "./Statement"
 import { SwitchCaseStatement } from "./SwitchCaseStatement"
 
 export class SwitchStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 88)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement {
-        const result: SwitchStatement = new SwitchStatement(global.generatedEs2panda._CreateSwitchStatement(global.context, passNode(discriminant), passNodeArray(cases), cases.length))
+        const result: SwitchStatement = new SwitchStatement(global.generatedEs2panda._CreateSwitchStatement(global.context, passNode(discriminant), passNodeArray(cases), cases.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateSwitchStatement(original: SwitchStatement | undefined, discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement {
-        const result: SwitchStatement = new SwitchStatement(global.generatedEs2panda._UpdateSwitchStatement(global.context, passNode(original), passNode(discriminant), passNodeArray(cases), cases.length))
+        const result: SwitchStatement = new SwitchStatement(global.generatedEs2panda._UpdateSwitchStatement(global.context, passNode(original), passNode(discriminant), passNodeArray(cases), cases.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -61,7 +59,7 @@ export class SwitchStatement extends Statement {
         return this
     }
     get cases(): readonly SwitchCaseStatement[] {
-        return unpackNodeArray(global.generatedEs2panda._SwitchStatementCases(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._SwitchStatementCases(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT)
     }
     protected readonly brandSwitchStatement: undefined
 }
@@ -69,5 +67,5 @@ export function isSwitchStatement(node: object | undefined): node is SwitchState
     return node instanceof SwitchStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT, (peer: KNativePointer) => new SwitchStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT, (peer: KNativePointer) => new SwitchStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSAnyKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 93)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSAnyKeyword(): TSAnyKeyword {
-        const result: TSAnyKeyword = new TSAnyKeyword(global.generatedEs2panda._CreateTSAnyKeyword(global.context))
+        const result: TSAnyKeyword = new TSAnyKeyword(global.generatedEs2panda._CreateTSAnyKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSAnyKeyword(original?: TSAnyKeyword): TSAnyKeyword {
-        const result: TSAnyKeyword = new TSAnyKeyword(global.generatedEs2panda._UpdateTSAnyKeyword(global.context, passNode(original)))
+        const result: TSAnyKeyword = new TSAnyKeyword(global.generatedEs2panda._UpdateTSAnyKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isTSAnyKeyword(node: object | undefined): node is TSAnyKeyword {
     return node instanceof 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))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD, (peer: KNativePointer) => new TSAnyKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSArrayType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 104)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSArrayType(elementType?: TypeNode): TSArrayType {
-        const result: TSArrayType = new TSArrayType(global.generatedEs2panda._CreateTSArrayType(global.context, passNode(elementType)))
+        const result: TSArrayType = new TSArrayType(global.generatedEs2panda._CreateTSArrayType(global.context, passNode(elementType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSArrayType(original?: TSArrayType, elementType?: TypeNode): TSArrayType {
-        const result: TSArrayType = new TSArrayType(global.generatedEs2panda._UpdateTSArrayType(global.context, passNode(original), passNode(elementType)))
+        const result: TSArrayType = new TSArrayType(global.generatedEs2panda._UpdateTSArrayType(global.context, passNode(original), passNode(elementType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isTSArrayType(node: object | undefined): node is TSArrayType {
     return node instanceof TSArrayType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE, (peer: KNativePointer) => new TSArrayType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE, (peer: KNativePointer) => new TSArrayType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,17 +37,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSAsExpression extends AnnotatedExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 140)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSAsExpression(expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression {
-        const result: TSAsExpression = new TSAsExpression(global.generatedEs2panda._CreateTSAsExpression(global.context, passNode(expression), passNode(typeAnnotation), isConst))
+        const result: TSAsExpression = new TSAsExpression(global.generatedEs2panda._CreateTSAsExpression(global.context, passNode(expression), passNode(typeAnnotation), isConst), Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSAsExpression(original: TSAsExpression | undefined, expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression {
-        const result: TSAsExpression = new TSAsExpression(global.generatedEs2panda._UpdateTSAsExpression(global.context, passNode(original), passNode(expression), passNode(typeAnnotation), isConst))
+        const result: TSAsExpression = new TSAsExpression(global.generatedEs2panda._UpdateTSAsExpression(global.context, passNode(original), passNode(expression), passNode(typeAnnotation), isConst), Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -82,5 +80,5 @@ export function isTSAsExpression(node: object | undefined): node is TSAsExpressi
     return node instanceof TSAsExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION, (peer: KNativePointer) => new TSAsExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION, (peer: KNativePointer) => new TSAsExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION))
 }