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

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,25 +37,24 @@ import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TypeNode } from "./TypeNode"
 
 export class NamedType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 48)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createNamedType(name?: Identifier): NamedType {
-        const result: NamedType = new NamedType(global.generatedEs2panda._CreateNamedType(global.context, passNode(name)))
+        const result: NamedType = new NamedType(global.generatedEs2panda._CreateNamedType(global.context, passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateNamedType(original?: NamedType, name?: Identifier): NamedType {
-        const result: NamedType = new NamedType(global.generatedEs2panda._UpdateNamedType(global.context, passNode(original), passNode(name)))
+        const result: NamedType = new NamedType(global.generatedEs2panda._UpdateNamedType(global.context, passNode(original), passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     get name(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._NamedTypeNameConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._NamedTypeNameConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get typeParams(): TSTypeParameterInstantiation | undefined {
-        return unpackNode(global.generatedEs2panda._NamedTypeTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._NamedTypeTypeParamsConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
     }
     get isNullable(): boolean {
         return global.generatedEs2panda._NamedTypeIsNullableConst(global.context, this.peer)
@@ -82,5 +80,5 @@ export function isNamedType(node: object | undefined): node is NamedType {
     return node instanceof NamedType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE, (peer: KNativePointer) => new NamedType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE, (peer: KNativePointer) => new NamedType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/NewExpression.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 NewExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 49)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createNewExpression(callee: Expression | undefined, _arguments: readonly Expression[]): NewExpression {
-        const result: NewExpression = new NewExpression(global.generatedEs2panda._CreateNewExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length))
+        const result: NewExpression = new NewExpression(global.generatedEs2panda._CreateNewExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateNewExpression(original: NewExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[]): NewExpression {
-        const result: NewExpression = new NewExpression(global.generatedEs2panda._UpdateNewExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length))
+        const result: NewExpression = new NewExpression(global.generatedEs2panda._UpdateNewExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -62,5 +60,5 @@ export function isNewExpression(node: object | undefined): node is NewExpression
     return node instanceof NewExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION, (peer: KNativePointer) => new NewExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION, (peer: KNativePointer) => new NewExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 
 export class NullLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 50)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createNullLiteral(): NullLiteral {
-        const result: NullLiteral = new NullLiteral(global.generatedEs2panda._CreateNullLiteral(global.context))
+        const result: NullLiteral = new NullLiteral(global.generatedEs2panda._CreateNullLiteral(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateNullLiteral(original?: NullLiteral): NullLiteral {
-        const result: NullLiteral = new NullLiteral(global.generatedEs2panda._UpdateNullLiteral(global.context, passNode(original)))
+        const result: NullLiteral = new NullLiteral(global.generatedEs2panda._UpdateNullLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isNullLiteral(node: object | undefined): node is NullLiteral {
     return node instanceof NullLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL, (peer: KNativePointer) => new NullLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL, (peer: KNativePointer) => new NullLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -34,45 +33,46 @@ import {
 
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
+import { extension_NumberLiteralValue } from "./../../reexport-for-generated"
 
 export class NumberLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 52)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createNumberLiteral(value: number): AstNode {
-        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, value))
+        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateNumberLiteral(original: AstNode | undefined, value: number): AstNode {
-        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral(global.context, passNode(original), value))
+        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static update1NumberLiteral(original: AstNode | undefined, value: number): AstNode {
-        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral1(global.context, passNode(original), value))
+        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral1(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static update2NumberLiteral(original: AstNode | undefined, value: number): AstNode {
-        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral2(global.context, passNode(original), value))
+        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral2(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static update3NumberLiteral(original: AstNode | undefined, value: number): AstNode {
-        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral3(global.context, passNode(original), value))
+        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral3(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     get str(): string {
         return unpackString(global.generatedEs2panda._NumberLiteralStrConst(global.context, this.peer))
     }
+    value = extension_NumberLiteralValue
     protected readonly brandNumberLiteral: undefined
 }
 export function isNumberLiteral(node: object | undefined): node is NumberLiteral {
     return node instanceof NumberLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, (peer: KNativePointer) => new NumberLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, (peer: KNativePointer) => new NumberLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL))
 }

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

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

package/build/libarkts-copy/src/generated/peers/ObjectExpression.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 ObjectExpression extends AnnotatedExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 163)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createObjectExpression(nodeType: Es2pandaAstNodeType, properties: readonly Expression[], trailingComma: boolean): ObjectExpression {
-        const result: ObjectExpression = new ObjectExpression(global.generatedEs2panda._CreateObjectExpression(global.context, nodeType, passNodeArray(properties), properties.length, trailingComma))
+        const result: ObjectExpression = new ObjectExpression(global.generatedEs2panda._CreateObjectExpression(global.context, nodeType, passNodeArray(properties), properties.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateObjectExpression(original: ObjectExpression | undefined, nodeType: Es2pandaAstNodeType, properties: readonly Expression[], trailingComma: boolean): ObjectExpression {
-        const result: ObjectExpression = new ObjectExpression(global.generatedEs2panda._UpdateObjectExpression(global.context, passNode(original), nodeType, passNodeArray(properties), properties.length, trailingComma))
+        const result: ObjectExpression = new ObjectExpression(global.generatedEs2panda._UpdateObjectExpression(global.context, passNode(original), nodeType, passNodeArray(properties), properties.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -63,9 +60,6 @@ export class ObjectExpression extends AnnotatedExpression {
     get isOptional(): boolean {
         return global.generatedEs2panda._ObjectExpressionIsOptionalConst(global.context, this.peer)
     }
-    get decorators(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._ObjectExpressionDecoratorsConst(global.context, this.peer))
-    }
     get validateExpression(): ValidationInfo | undefined {
         return new ValidationInfo(global.generatedEs2panda._ObjectExpressionValidateExpression(global.context, this.peer))
     }
@@ -96,5 +90,5 @@ export function isObjectExpression(node: object | undefined): node is ObjectExpr
     return node instanceof ObjectExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, (peer: KNativePointer) => new ObjectExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, (peer: KNativePointer) => new ObjectExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/OmittedExpression.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 OmittedExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 53)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createOmittedExpression(): OmittedExpression {
-        const result: OmittedExpression = new OmittedExpression(global.generatedEs2panda._CreateOmittedExpression(global.context))
+        const result: OmittedExpression = new OmittedExpression(global.generatedEs2panda._CreateOmittedExpression(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateOmittedExpression(original?: OmittedExpression): OmittedExpression {
-        const result: OmittedExpression = new OmittedExpression(global.generatedEs2panda._UpdateOmittedExpression(global.context, passNode(original)))
+        const result: OmittedExpression = new OmittedExpression(global.generatedEs2panda._UpdateOmittedExpression(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isOmittedExpression(node: object | undefined): node is OmittedEx
     return node instanceof OmittedExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION, (peer: KNativePointer) => new OmittedExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION, (peer: KNativePointer) => new OmittedExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/OpaqueTypeNode.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 OpaqueTypeNode extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 156)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1OpaqueTypeNode(): OpaqueTypeNode {
-        const result: OpaqueTypeNode = new OpaqueTypeNode(global.generatedEs2panda._CreateOpaqueTypeNode1(global.context))
+        const result: OpaqueTypeNode = new OpaqueTypeNode(global.generatedEs2panda._CreateOpaqueTypeNode1(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE)
         result.setChildrenParentPtr()
         return result
     }
     static update1OpaqueTypeNode(original?: OpaqueTypeNode): OpaqueTypeNode {
-        const result: OpaqueTypeNode = new OpaqueTypeNode(global.generatedEs2panda._UpdateOpaqueTypeNode1(global.context, passNode(original)))
+        const result: OpaqueTypeNode = new OpaqueTypeNode(global.generatedEs2panda._UpdateOpaqueTypeNode1(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isOpaqueTypeNode(node: object | undefined): node is OpaqueTypeNo
     return node instanceof OpaqueTypeNode
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE, (peer: KNativePointer) => new OpaqueTypeNode(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE, (peer: KNativePointer) => new OpaqueTypeNode(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -41,17 +40,16 @@ import { Identifier } from "./Identifier"
 import { SrcDumper } from "./SrcDumper"
 
 export class OverloadDeclaration extends ClassElement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 54)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createOverloadDeclaration(key: Expression | undefined, modifiers: Es2pandaModifierFlags): OverloadDeclaration {
-        const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._CreateOverloadDeclaration(global.context, passNode(key), modifiers))
+        const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._CreateOverloadDeclaration(global.context, passNode(key), modifiers), Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateOverloadDeclaration(original: OverloadDeclaration | undefined, key: Expression | undefined, modifiers: Es2pandaModifierFlags): OverloadDeclaration {
-        const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._UpdateOverloadDeclaration(global.context, passNode(original), passNode(key), modifiers))
+        const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._UpdateOverloadDeclaration(global.context, passNode(original), passNode(key), modifiers), Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -99,5 +97,5 @@ export function isOverloadDeclaration(node: object | undefined): node is Overloa
     return node instanceof OverloadDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION, (peer: KNativePointer) => new OverloadDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION, (peer: KNativePointer) => new OverloadDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class PrefixAssertionExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 55)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createPrefixAssertionExpression(expr?: Expression, type?: TypeNode): PrefixAssertionExpression {
-        const result: PrefixAssertionExpression = new PrefixAssertionExpression(global.generatedEs2panda._CreatePrefixAssertionExpression(global.context, passNode(expr), passNode(type)))
+        const result: PrefixAssertionExpression = new PrefixAssertionExpression(global.generatedEs2panda._CreatePrefixAssertionExpression(global.context, passNode(expr), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updatePrefixAssertionExpression(original?: PrefixAssertionExpression, expr?: Expression, type?: TypeNode): PrefixAssertionExpression {
-        const result: PrefixAssertionExpression = new PrefixAssertionExpression(global.generatedEs2panda._UpdatePrefixAssertionExpression(global.context, passNode(original), passNode(expr), passNode(type)))
+        const result: PrefixAssertionExpression = new PrefixAssertionExpression(global.generatedEs2panda._UpdatePrefixAssertionExpression(global.context, passNode(original), passNode(expr), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -63,5 +61,5 @@ export function isPrefixAssertionExpression(node: object | undefined): node is P
     return node instanceof PrefixAssertionExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION, (peer: KNativePointer) => new PrefixAssertionExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION, (peer: KNativePointer) => new PrefixAssertionExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -34,10 +33,12 @@ import {
 
 import { BlockStatement } from "./BlockStatement"
 import { ClassDefinition } from "./ClassDefinition"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaModuleKind } from "./../Es2pandaEnums"
 import { Es2pandaProgramFlags } from "./../Es2pandaEnums"
 import { Es2pandaScriptKind } from "./../Es2pandaEnums"
 import { SourcePosition } from "./SourcePosition"
+import { extension_ProgramGetAstCasted } from "./../../reexport-for-generated"
 import { extension_ProgramGetExternalSources } from "./../../reexport-for-generated"
 
 export class Program extends ArktsObject {
@@ -100,7 +101,7 @@ export class Program extends ArktsObject {
         return this
     }
     get globalClass(): ClassDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._ProgramGlobalClass(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ProgramGlobalClass(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
     }
     /** @deprecated */
     setGlobalClass(globalClass?: ClassDefinition): this {
@@ -153,6 +154,11 @@ export class Program extends ArktsObject {
         global.generatedEs2panda._ProgramSetASTChecked(global.context, this.peer)
         return this
     }
+    /** @deprecated */
+    removeAstChecked(): this {
+        global.generatedEs2panda._ProgramRemoveAstChecked(global.context, this.peer)
+        return this
+    }
     get isASTChecked(): boolean {
         return global.generatedEs2panda._ProgramIsASTChecked(global.context, this.peer)
     }
@@ -191,6 +197,7 @@ export class Program extends ArktsObject {
         global.generatedEs2panda._ProgramAddFileDependencies(global.context, this.peer, file, depFile)
         return this
     }
+    getAstCasted = extension_ProgramGetAstCasted
     getExternalSources = extension_ProgramGetExternalSources
     protected readonly brandProgram: undefined
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,22 +37,21 @@ import { Expression } from "./Expression"
 import { ValidationInfo } from "./ValidationInfo"
 
 export class Property extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 56)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1Property(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property {
-        const result: Property = new Property(global.generatedEs2panda._CreateProperty1(global.context, kind, passNode(key), passNode(value), isMethod, isComputed))
+        const result: Property = new Property(global.generatedEs2panda._CreateProperty1(global.context, kind, passNode(key), passNode(value), isMethod, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)
         result.setChildrenParentPtr()
         return result
     }
     static updateProperty(original?: Property, key?: Expression, value?: Expression): Property {
-        const result: Property = new Property(global.generatedEs2panda._UpdateProperty(global.context, passNode(original), passNode(key), passNode(value)))
+        const result: Property = new Property(global.generatedEs2panda._UpdateProperty(global.context, passNode(original), passNode(key), passNode(value)), Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)
         result.setChildrenParentPtr()
         return result
     }
     static update1Property(original: Property | undefined, kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property {
-        const result: Property = new Property(global.generatedEs2panda._UpdateProperty1(global.context, passNode(original), kind, passNode(key), passNode(value), isMethod, isComputed))
+        const result: Property = new Property(global.generatedEs2panda._UpdateProperty1(global.context, passNode(original), kind, passNode(key), passNode(value), isMethod, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)
         result.setChildrenParentPtr()
         return result
     }
@@ -90,5 +88,5 @@ export function isProperty(node: object | undefined): node is Property {
     return node instanceof Property
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY, (peer: KNativePointer) => new Property(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY, (peer: KNativePointer) => new Property(peer, Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Es2pandaRegExpFlags } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 
 export class RegExpLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 57)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral {
-        const result: RegExpLiteral = new RegExpLiteral(global.generatedEs2panda._CreateRegExpLiteral(global.context, pattern, flags, flagsStr))
+        const result: RegExpLiteral = new RegExpLiteral(global.generatedEs2panda._CreateRegExpLiteral(global.context, pattern, flags, flagsStr), Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateRegExpLiteral(original: RegExpLiteral | undefined, pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral {
-        const result: RegExpLiteral = new RegExpLiteral(global.generatedEs2panda._UpdateRegExpLiteral(global.context, passNode(original), pattern, flags, flagsStr))
+        const result: RegExpLiteral = new RegExpLiteral(global.generatedEs2panda._UpdateRegExpLiteral(global.context, passNode(original), pattern, flags, flagsStr), Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -63,5 +61,5 @@ export function isRegExpLiteral(node: object | undefined): node is RegExpLiteral
     return node instanceof RegExpLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL, (peer: KNativePointer) => new RegExpLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL, (peer: KNativePointer) => new RegExpLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,22 +36,21 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class ReturnStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 59)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1ReturnStatement(argument?: Expression): ReturnStatement {
-        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument)))
+        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateReturnStatement(original?: ReturnStatement): ReturnStatement {
-        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original)))
+        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1ReturnStatement(original?: ReturnStatement, argument?: Expression): ReturnStatement {
-        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument)))
+        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +71,5 @@ export function isReturnStatement(node: object | undefined): node is ReturnState
     return node instanceof ReturnStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, (peer: KNativePointer) => new ReturnStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, (peer: KNativePointer) => new ReturnStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT))
 }

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

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