npm - @idlizer/arktscgen - Versions diffs - 2.1.9-arktscgen-9 → 2.1.10-arktscgen-3 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (296) hide show

package/build/libarkts-copy/src/generated/peers/TSTypeOperator.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Es2pandaTSOperatorType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class TSTypeOperator extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 119)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeOperator(type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator {
-        const result: TSTypeOperator = new TSTypeOperator(global.generatedEs2panda._CreateTSTypeOperator(global.context, passNode(type), operatorType))
+        const result: TSTypeOperator = new TSTypeOperator(global.generatedEs2panda._CreateTSTypeOperator(global.context, passNode(type), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeOperator(original: TSTypeOperator | undefined, type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator {
-        const result: TSTypeOperator = new TSTypeOperator(global.generatedEs2panda._UpdateTSTypeOperator(global.context, passNode(original), passNode(type), operatorType))
+        const result: TSTypeOperator = new TSTypeOperator(global.generatedEs2panda._UpdateTSTypeOperator(global.context, passNode(original), passNode(type), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR)
         result.setChildrenParentPtr()
         return result
     }
@@ -69,5 +67,5 @@ export function isTSTypeOperator(node: object | undefined): node is TSTypeOperat
     return node instanceof TSTypeOperator
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR, (peer: KNativePointer) => new TSTypeOperator(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR, (peer: KNativePointer) => new TSTypeOperator(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR))
 }

package/build/libarkts-copy/src/generated/peers/TSTypeParameter.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,30 +36,30 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
+import { SrcDumper } from "./SrcDumper"
 import { TypeNode } from "./TypeNode"
 export class TSTypeParameter extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 120)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1TSTypeParameter(name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter {
-        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter1(global.context, passNode(name), passNode(constraint), passNode(defaultType), flags))
+        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter1(global.context, passNode(name), passNode(constraint), passNode(defaultType), flags), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeParameter(original?: TSTypeParameter, name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter {
-        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType)))
+        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)
         result.setChildrenParentPtr()
         return result
     }
     static update1TSTypeParameter(original: TSTypeParameter | undefined, name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter {
-        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter1(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType), flags))
+        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter1(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType), flags), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)
         result.setChildrenParentPtr()
         return result
     }
     get name(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._TSTypeParameterName(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSTypeParameterName(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get constraint(): TypeNode | undefined {
         return unpackNode(global.generatedEs2panda._TSTypeParameterConstraint(global.context, this.peer))
@@ -78,9 +77,12 @@ export class TSTypeParameter extends Expression {
         global.generatedEs2panda._TSTypeParameterSetDefaultType(global.context, this.peer, passNode(defaultType))
         return this
     }
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._TSTypeParameterHasAnnotationsConst(global.context, this.peer)
+    }
     /** @deprecated */
-    emplaceAnnotations(source?: AnnotationUsage): this {
-        global.generatedEs2panda._TSTypeParameterEmplaceAnnotations(global.context, this.peer, passNode(source))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._TSTypeParameterEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -89,15 +91,15 @@ export class TSTypeParameter extends Expression {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(source: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._TSTypeParameterSetValueAnnotations(global.context, this.peer, passNode(source), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._TSTypeParameterDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._TSTypeParameterAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSTypeParameterAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._TSTypeParameterAnnotations(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSTypeParameterAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
     setAnnotations(annotationList: readonly AnnotationUsage[]): this {
@@ -109,16 +111,11 @@ export class TSTypeParameter extends Expression {
         global.generatedEs2panda._TSTypeParameterSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    /** @deprecated */
-    addAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._TSTypeParameterAddAnnotations(global.context, this.peer, passNode(annotations))
-        return this
-    }
     protected readonly brandTSTypeParameter: undefined
 }
 export function isTSTypeParameter(node: object | undefined): node is TSTypeParameter {
     return node instanceof TSTypeParameter
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, (peer: KNativePointer) => new TSTypeParameter(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, (peer: KNativePointer) => new TSTypeParameter(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER))
 }

package/build/libarkts-copy/src/generated/peers/TSTypeParameterDeclaration.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,22 +36,21 @@ import { Expression } from "./Expression"
 import { TSTypeParameter } from "./TSTypeParameter"
 export class TSTypeParameterDeclaration extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 121)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], requiredParams: number): TSTypeParameterDeclaration {
-        const result: TSTypeParameterDeclaration = new TSTypeParameterDeclaration(global.generatedEs2panda._CreateTSTypeParameterDeclaration(global.context, passNodeArray(params), params.length, requiredParams))
+        const result: TSTypeParameterDeclaration = new TSTypeParameterDeclaration(global.generatedEs2panda._CreateTSTypeParameterDeclaration(global.context, passNodeArray(params), params.length, requiredParams), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration | undefined, params: readonly TSTypeParameter[], requiredParams: number): TSTypeParameterDeclaration {
-        const result: TSTypeParameterDeclaration = new TSTypeParameterDeclaration(global.generatedEs2panda._UpdateTSTypeParameterDeclaration(global.context, passNode(original), passNodeArray(params), params.length, requiredParams))
+        const result: TSTypeParameterDeclaration = new TSTypeParameterDeclaration(global.generatedEs2panda._UpdateTSTypeParameterDeclaration(global.context, passNode(original), passNodeArray(params), params.length, requiredParams), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     get params(): readonly TSTypeParameter[] {
-        return unpackNodeArray(global.generatedEs2panda._TSTypeParameterDeclarationParamsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSTypeParameterDeclarationParamsConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)
     }
     /** @deprecated */
     addParam(param?: TSTypeParameter): this {
@@ -73,5 +71,5 @@ export function isTSTypeParameterDeclaration(node: object | undefined): node is
     return node instanceof TSTypeParameterDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, (peer: KNativePointer) => new TSTypeParameterDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, (peer: KNativePointer) => new TSTypeParameterDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION))
 }

package/build/libarkts-copy/src/generated/peers/TSTypeParameterInstantiation.ts CHANGED Viewed

@@ -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 TSTypeParameterInstantiation extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 122)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeParameterInstantiation(params: readonly TypeNode[]): TSTypeParameterInstantiation {
-        const result: TSTypeParameterInstantiation = new TSTypeParameterInstantiation(global.generatedEs2panda._CreateTSTypeParameterInstantiation(global.context, passNodeArray(params), params.length))
+        const result: TSTypeParameterInstantiation = new TSTypeParameterInstantiation(global.generatedEs2panda._CreateTSTypeParameterInstantiation(global.context, passNodeArray(params), params.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation | undefined, params: readonly TypeNode[]): TSTypeParameterInstantiation {
-        const result: TSTypeParameterInstantiation = new TSTypeParameterInstantiation(global.generatedEs2panda._UpdateTSTypeParameterInstantiation(global.context, passNode(original), passNodeArray(params), params.length))
+        const result: TSTypeParameterInstantiation = new TSTypeParameterInstantiation(global.generatedEs2panda._UpdateTSTypeParameterInstantiation(global.context, passNode(original), passNodeArray(params), params.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +58,5 @@ export function isTSTypeParameterInstantiation(node: object | undefined): node i
     return node instanceof TSTypeParameterInstantiation
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION, (peer: KNativePointer) => new TSTypeParameterInstantiation(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION, (peer: KNativePointer) => new TSTypeParameterInstantiation(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION))
 }

package/build/libarkts-copy/src/generated/peers/TSTypePredicate.ts CHANGED Viewed

@@ -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 TSTypePredicate extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 123)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypePredicate(parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate {
-        const result: TSTypePredicate = new TSTypePredicate(global.generatedEs2panda._CreateTSTypePredicate(global.context, passNode(parameterName), passNode(typeAnnotation), asserts))
+        const result: TSTypePredicate = new TSTypePredicate(global.generatedEs2panda._CreateTSTypePredicate(global.context, passNode(parameterName), passNode(typeAnnotation), asserts), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypePredicate(original: TSTypePredicate | undefined, parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate {
-        const result: TSTypePredicate = new TSTypePredicate(global.generatedEs2panda._UpdateTSTypePredicate(global.context, passNode(original), passNode(parameterName), passNode(typeAnnotation), asserts))
+        const result: TSTypePredicate = new TSTypePredicate(global.generatedEs2panda._UpdateTSTypePredicate(global.context, passNode(original), passNode(parameterName), passNode(typeAnnotation), asserts), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE)
         result.setChildrenParentPtr()
         return result
     }
@@ -66,5 +64,5 @@ export function isTSTypePredicate(node: object | undefined): node is TSTypePredi
     return node instanceof TSTypePredicate
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE, (peer: KNativePointer) => new TSTypePredicate(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE, (peer: KNativePointer) => new TSTypePredicate(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE))
 }

package/build/libarkts-copy/src/generated/peers/TSTypeQuery.ts CHANGED Viewed

@@ -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 TSTypeQuery extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 139)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeQuery(exprName?: Expression): TSTypeQuery {
-        const result: TSTypeQuery = new TSTypeQuery(global.generatedEs2panda._CreateTSTypeQuery(global.context, passNode(exprName)))
+        const result: TSTypeQuery = new TSTypeQuery(global.generatedEs2panda._CreateTSTypeQuery(global.context, passNode(exprName)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeQuery(original?: TSTypeQuery, exprName?: Expression): TSTypeQuery {
-        const result: TSTypeQuery = new TSTypeQuery(global.generatedEs2panda._UpdateTSTypeQuery(global.context, passNode(original), passNode(exprName)))
+        const result: TSTypeQuery = new TSTypeQuery(global.generatedEs2panda._UpdateTSTypeQuery(global.context, passNode(original), passNode(exprName)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +58,5 @@ export function isTSTypeQuery(node: object | undefined): node is TSTypeQuery {
     return node instanceof TSTypeQuery
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY, (peer: KNativePointer) => new TSTypeQuery(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY, (peer: KNativePointer) => new TSTypeQuery(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY))
 }

package/build/libarkts-copy/src/generated/peers/TSTypeReference.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -39,28 +38,27 @@ import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TypeNode } from "./TypeNode"
 export class TSTypeReference extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 130)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeReference(typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference {
-        const result: TSTypeReference = new TSTypeReference(global.generatedEs2panda._CreateTSTypeReference(global.context, passNode(typeName), passNode(typeParams)))
+        const result: TSTypeReference = new TSTypeReference(global.generatedEs2panda._CreateTSTypeReference(global.context, passNode(typeName), passNode(typeParams)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeReference(original?: TSTypeReference, typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference {
-        const result: TSTypeReference = new TSTypeReference(global.generatedEs2panda._UpdateTSTypeReference(global.context, passNode(original), passNode(typeName), passNode(typeParams)))
+        const result: TSTypeReference = new TSTypeReference(global.generatedEs2panda._UpdateTSTypeReference(global.context, passNode(original), passNode(typeName), passNode(typeParams)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE)
         result.setChildrenParentPtr()
         return result
     }
     get typeParams(): TSTypeParameterInstantiation | undefined {
-        return unpackNode(global.generatedEs2panda._TSTypeReferenceTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSTypeReferenceTypeParamsConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
     }
     get typeName(): Expression | undefined {
         return unpackNode(global.generatedEs2panda._TSTypeReferenceTypeNameConst(global.context, this.peer))
     }
     get baseName(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._TSTypeReferenceBaseNameConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSTypeReferenceBaseNameConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     protected readonly brandTSTypeReference: undefined
 }
@@ -68,5 +66,5 @@ export function isTSTypeReference(node: object | undefined): node is TSTypeRefer
     return node instanceof TSTypeReference
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE, (peer: KNativePointer) => new TSTypeReference(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE, (peer: KNativePointer) => new TSTypeReference(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE))
 }

package/build/libarkts-copy/src/generated/peers/TSUndefinedKeyword.ts CHANGED Viewed

@@ -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 TSUndefinedKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 97)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSUndefinedKeyword(): TSUndefinedKeyword {
-        const result: TSUndefinedKeyword = new TSUndefinedKeyword(global.generatedEs2panda._CreateTSUndefinedKeyword(global.context))
+        const result: TSUndefinedKeyword = new TSUndefinedKeyword(global.generatedEs2panda._CreateTSUndefinedKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSUndefinedKeyword(original?: TSUndefinedKeyword): TSUndefinedKeyword {
-        const result: TSUndefinedKeyword = new TSUndefinedKeyword(global.generatedEs2panda._UpdateTSUndefinedKeyword(global.context, passNode(original)))
+        const result: TSUndefinedKeyword = new TSUndefinedKeyword(global.generatedEs2panda._UpdateTSUndefinedKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isTSUndefinedKeyword(node: object | undefined): node is TSUndefi
     return node instanceof TSUndefinedKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD, (peer: KNativePointer) => new TSUndefinedKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD, (peer: KNativePointer) => new TSUndefinedKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD))
 }

package/build/libarkts-copy/src/generated/peers/TSUnionType.ts CHANGED Viewed

@@ -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 TSUnionType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 105)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSUnionType(types: readonly TypeNode[]): TSUnionType {
-        const result: TSUnionType = new TSUnionType(global.generatedEs2panda._CreateTSUnionType(global.context, passNodeArray(types), types.length))
+        const result: TSUnionType = new TSUnionType(global.generatedEs2panda._CreateTSUnionType(global.context, passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSUnionType(original: TSUnionType | undefined, types: readonly TypeNode[]): TSUnionType {
-        const result: TSUnionType = new TSUnionType(global.generatedEs2panda._UpdateTSUnionType(global.context, passNode(original), passNodeArray(types), types.length))
+        const result: TSUnionType = new TSUnionType(global.generatedEs2panda._UpdateTSUnionType(global.context, passNode(original), passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isTSUnionType(node: object | undefined): node is TSUnionType {
     return node instanceof TSUnionType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE, (peer: KNativePointer) => new TSUnionType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE, (peer: KNativePointer) => new TSUnionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/TSUnknownKeyword.ts CHANGED Viewed

@@ -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 TSUnknownKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 98)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSUnknownKeyword(): TSUnknownKeyword {
-        const result: TSUnknownKeyword = new TSUnknownKeyword(global.generatedEs2panda._CreateTSUnknownKeyword(global.context))
+        const result: TSUnknownKeyword = new TSUnknownKeyword(global.generatedEs2panda._CreateTSUnknownKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSUnknownKeyword(original?: TSUnknownKeyword): TSUnknownKeyword {
-        const result: TSUnknownKeyword = new TSUnknownKeyword(global.generatedEs2panda._UpdateTSUnknownKeyword(global.context, passNode(original)))
+        const result: TSUnknownKeyword = new TSUnknownKeyword(global.generatedEs2panda._UpdateTSUnknownKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isTSUnknownKeyword(node: object | undefined): node is TSUnknownK
     return node instanceof TSUnknownKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD, (peer: KNativePointer) => new TSUnknownKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD, (peer: KNativePointer) => new TSUnknownKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD))
 }

package/build/libarkts-copy/src/generated/peers/TSVoidKeyword.ts CHANGED Viewed

@@ -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 TSVoidKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 96)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSVoidKeyword(): TSVoidKeyword {
-        const result: TSVoidKeyword = new TSVoidKeyword(global.generatedEs2panda._CreateTSVoidKeyword(global.context))
+        const result: TSVoidKeyword = new TSVoidKeyword(global.generatedEs2panda._CreateTSVoidKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSVoidKeyword(original?: TSVoidKeyword): TSVoidKeyword {
-        const result: TSVoidKeyword = new TSVoidKeyword(global.generatedEs2panda._UpdateTSVoidKeyword(global.context, passNode(original)))
+        const result: TSVoidKeyword = new TSVoidKeyword(global.generatedEs2panda._UpdateTSVoidKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isTSVoidKeyword(node: object | undefined): node is TSVoidKeyword
     return node instanceof TSVoidKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD, (peer: KNativePointer) => new TSVoidKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD, (peer: KNativePointer) => new TSVoidKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD))
 }

package/build/libarkts-copy/src/generated/peers/TaggedTemplateExpression.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,17 +37,16 @@ import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TemplateLiteral } from "./TemplateLiteral"
 export class TaggedTemplateExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 143)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTaggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression {
-        const result: TaggedTemplateExpression = new TaggedTemplateExpression(global.generatedEs2panda._CreateTaggedTemplateExpression(global.context, passNode(tag), passNode(quasi), passNode(typeParams)))
+        const result: TaggedTemplateExpression = new TaggedTemplateExpression(global.generatedEs2panda._CreateTaggedTemplateExpression(global.context, passNode(tag), passNode(quasi), passNode(typeParams)), Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTaggedTemplateExpression(original?: TaggedTemplateExpression, tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression {
-        const result: TaggedTemplateExpression = new TaggedTemplateExpression(global.generatedEs2panda._UpdateTaggedTemplateExpression(global.context, passNode(original), passNode(tag), passNode(quasi), passNode(typeParams)))
+        const result: TaggedTemplateExpression = new TaggedTemplateExpression(global.generatedEs2panda._UpdateTaggedTemplateExpression(global.context, passNode(original), passNode(tag), passNode(quasi), passNode(typeParams)), Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,10 +54,10 @@ export class TaggedTemplateExpression extends Expression {
         return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionTagConst(global.context, this.peer))
     }
     get quasi(): TemplateLiteral | undefined {
-        return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionQuasiConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionQuasiConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL)
     }
     get typeParams(): TSTypeParameterInstantiation | undefined {
-        return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionTypeParamsConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
     }
     protected readonly brandTaggedTemplateExpression: undefined
 }
@@ -67,5 +65,5 @@ export function isTaggedTemplateExpression(node: object | undefined): node is Ta
     return node instanceof TaggedTemplateExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION, (peer: KNativePointer) => new TaggedTemplateExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION, (peer: KNativePointer) => new TaggedTemplateExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/TemplateElement.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,22 +35,21 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class TemplateElement extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 144)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1TemplateElement(raw: string, cooked: string): TemplateElement {
-        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._CreateTemplateElement1(global.context, raw, cooked))
+        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._CreateTemplateElement1(global.context, raw, cooked), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateTemplateElement(original?: TemplateElement): TemplateElement {
-        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._UpdateTemplateElement(global.context, passNode(original)))
+        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._UpdateTemplateElement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1TemplateElement(original: TemplateElement | undefined, raw: string, cooked: string): TemplateElement {
-        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._UpdateTemplateElement1(global.context, passNode(original), raw, cooked))
+        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._UpdateTemplateElement1(global.context, passNode(original), raw, cooked), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -67,5 +65,5 @@ export function isTemplateElement(node: object | undefined): node is TemplateEle
     return node instanceof TemplateElement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT, (peer: KNativePointer) => new TemplateElement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT, (peer: KNativePointer) => new TemplateElement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT))
 }

package/build/libarkts-copy/src/generated/peers/TemplateLiteral.ts CHANGED Viewed

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,22 +36,21 @@ import { Expression } from "./Expression"
 import { TemplateElement } from "./TemplateElement"
 export class TemplateLiteral extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 145)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTemplateLiteral(quasis: readonly TemplateElement[], expressions: readonly Expression[], multilineString: string): TemplateLiteral {
-        const result: TemplateLiteral = new TemplateLiteral(global.generatedEs2panda._CreateTemplateLiteral(global.context, passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString))
+        const result: TemplateLiteral = new TemplateLiteral(global.generatedEs2panda._CreateTemplateLiteral(global.context, passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateTemplateLiteral(original: TemplateLiteral | undefined, quasis: readonly TemplateElement[], expressions: readonly Expression[], multilineString: string): TemplateLiteral {
-        const result: TemplateLiteral = new TemplateLiteral(global.generatedEs2panda._UpdateTemplateLiteral(global.context, passNode(original), passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString))
+        const result: TemplateLiteral = new TemplateLiteral(global.generatedEs2panda._UpdateTemplateLiteral(global.context, passNode(original), passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     get quasis(): readonly TemplateElement[] {
-        return unpackNodeArray(global.generatedEs2panda._TemplateLiteralQuasisConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TemplateLiteralQuasisConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)
     }
     get expressions(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._TemplateLiteralExpressionsConst(global.context, this.peer))
@@ -66,5 +64,5 @@ export function isTemplateLiteral(node: object | undefined): node is TemplateLit
     return node instanceof TemplateLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL, (peer: KNativePointer) => new TemplateLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL, (peer: KNativePointer) => new TemplateLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL))
 }