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/TSNumberKeyword.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 TSNumberKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 92)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSNumberKeyword(): TSNumberKeyword {
-        const result: TSNumberKeyword = new TSNumberKeyword(global.generatedEs2panda._CreateTSNumberKeyword(global.context))
+        const result: TSNumberKeyword = new TSNumberKeyword(global.generatedEs2panda._CreateTSNumberKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSNumberKeyword(original?: TSNumberKeyword): TSNumberKeyword {
-        const result: TSNumberKeyword = new TSNumberKeyword(global.generatedEs2panda._UpdateTSNumberKeyword(global.context, passNode(original)))
+        const result: TSNumberKeyword = new TSNumberKeyword(global.generatedEs2panda._UpdateTSNumberKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isTSNumberKeyword(node: object | undefined): node is TSNumberKey
     return node instanceof TSNumberKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD, (peer: KNativePointer) => new TSNumberKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD, (peer: KNativePointer) => new TSNumberKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD))
 }

package/build/libarkts-copy/src/generated/peers/TSObjectKeyword.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 TSObjectKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 99)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSObjectKeyword(): TSObjectKeyword {
-        const result: TSObjectKeyword = new TSObjectKeyword(global.generatedEs2panda._CreateTSObjectKeyword(global.context))
+        const result: TSObjectKeyword = new TSObjectKeyword(global.generatedEs2panda._CreateTSObjectKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSObjectKeyword(original?: TSObjectKeyword): TSObjectKeyword {
-        const result: TSObjectKeyword = new TSObjectKeyword(global.generatedEs2panda._UpdateTSObjectKeyword(global.context, passNode(original)))
+        const result: TSObjectKeyword = new TSObjectKeyword(global.generatedEs2panda._UpdateTSObjectKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isTSObjectKeyword(node: object | undefined): node is TSObjectKey
     return node instanceof TSObjectKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD, (peer: KNativePointer) => new TSObjectKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD, (peer: KNativePointer) => new TSObjectKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class TSParameterProperty extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 124)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty {
-        const result: TSParameterProperty = new TSParameterProperty(global.generatedEs2panda._CreateTSParameterProperty(global.context, accessibility, passNode(parameter), readonly_arg, isStatic, isExport))
+        const result: TSParameterProperty = new TSParameterProperty(global.generatedEs2panda._CreateTSParameterProperty(global.context, accessibility, passNode(parameter), readonly_arg, isStatic, isExport), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSParameterProperty(original: TSParameterProperty | undefined, accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty {
-        const result: TSParameterProperty = new TSParameterProperty(global.generatedEs2panda._UpdateTSParameterProperty(global.context, passNode(original), accessibility, passNode(parameter), readonly_arg, isStatic, isExport))
+        const result: TSParameterProperty = new TSParameterProperty(global.generatedEs2panda._UpdateTSParameterProperty(global.context, passNode(original), accessibility, passNode(parameter), readonly_arg, isStatic, isExport), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY)
         result.setChildrenParentPtr()
         return result
     }
@@ -72,5 +70,5 @@ export function isTSParameterProperty(node: object | undefined): node is TSParam
     return node instanceof TSParameterProperty
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY, (peer: KNativePointer) => new TSParameterProperty(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY, (peer: KNativePointer) => new TSParameterProperty(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY))
 }

package/build/libarkts-copy/src/generated/peers/TSParenthesizedType.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 TSParenthesizedType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 110)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSParenthesizedType(type?: TypeNode): TSParenthesizedType {
-        const result: TSParenthesizedType = new TSParenthesizedType(global.generatedEs2panda._CreateTSParenthesizedType(global.context, passNode(type)))
+        const result: TSParenthesizedType = new TSParenthesizedType(global.generatedEs2panda._CreateTSParenthesizedType(global.context, passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSParenthesizedType(original?: TSParenthesizedType, type?: TypeNode): TSParenthesizedType {
-        const result: TSParenthesizedType = new TSParenthesizedType(global.generatedEs2panda._UpdateTSParenthesizedType(global.context, passNode(original), passNode(type)))
+        const result: TSParenthesizedType = new TSParenthesizedType(global.generatedEs2panda._UpdateTSParenthesizedType(global.context, passNode(original), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +58,5 @@ export function isTSParenthesizedType(node: object | undefined): node is TSParen
     return node instanceof TSParenthesizedType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE, (peer: KNativePointer) => new TSParenthesizedType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE, (peer: KNativePointer) => new TSParenthesizedType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE))
 }

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

@@ -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 TSPropertySignature extends AnnotatedAstNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 107)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSPropertySignature(key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature {
-        const result: TSPropertySignature = new TSPropertySignature(global.generatedEs2panda._CreateTSPropertySignature(global.context, passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg))
+        const result: TSPropertySignature = new TSPropertySignature(global.generatedEs2panda._CreateTSPropertySignature(global.context, passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSPropertySignature(original: TSPropertySignature | undefined, key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature {
-        const result: TSPropertySignature = new TSPropertySignature(global.generatedEs2panda._UpdateTSPropertySignature(global.context, passNode(original), passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg))
+        const result: TSPropertySignature = new TSPropertySignature(global.generatedEs2panda._UpdateTSPropertySignature(global.context, passNode(original), passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE)
         result.setChildrenParentPtr()
         return result
     }
@@ -78,5 +76,5 @@ export function isTSPropertySignature(node: object | undefined): node is TSPrope
     return node instanceof TSPropertySignature
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE, (peer: KNativePointer) => new TSPropertySignature(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE, (peer: KNativePointer) => new TSPropertySignature(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
 export class TSQualifiedName extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 131)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName {
-        const result: TSQualifiedName = new TSQualifiedName(global.generatedEs2panda._CreateTSQualifiedName(global.context, passNode(left), passNode(right)))
+        const result: TSQualifiedName = new TSQualifiedName(global.generatedEs2panda._CreateTSQualifiedName(global.context, passNode(left), passNode(right)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSQualifiedName(original?: TSQualifiedName, left?: Expression, right?: Identifier): TSQualifiedName {
-        const result: TSQualifiedName = new TSQualifiedName(global.generatedEs2panda._UpdateTSQualifiedName(global.context, passNode(original), passNode(left), passNode(right)))
+        const result: TSQualifiedName = new TSQualifiedName(global.generatedEs2panda._UpdateTSQualifiedName(global.context, passNode(original), passNode(left), passNode(right)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME)
         result.setChildrenParentPtr()
         return result
     }
@@ -55,13 +53,13 @@ export class TSQualifiedName extends Expression {
         return unpackNode(global.generatedEs2panda._TSQualifiedNameLeft(global.context, this.peer))
     }
     get right(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._TSQualifiedNameRight(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSQualifiedNameRight(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get name(): string {
         return unpackString(global.generatedEs2panda._TSQualifiedNameNameConst(global.context, this.peer))
     }
     get resolveLeftMostQualifiedName(): TSQualifiedName | undefined {
-        return unpackNode(global.generatedEs2panda._TSQualifiedNameResolveLeftMostQualifiedName(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSQualifiedNameResolveLeftMostQualifiedName(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME)
     }
     protected readonly brandTSQualifiedName: undefined
 }
@@ -69,5 +67,5 @@ export function isTSQualifiedName(node: object | undefined): node is TSQualified
     return node instanceof TSQualifiedName
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME, (peer: KNativePointer) => new TSQualifiedName(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME, (peer: KNativePointer) => new TSQualifiedName(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -41,22 +40,21 @@ import { TypeNode } from "./TypeNode"
 import { TypedAstNode } from "./TypedAstNode"
 export class TSSignatureDeclaration extends TypedAstNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 109)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSSignatureDeclaration(kind: Es2pandaTSSignatureDeclarationKind, signature?: FunctionSignature): TSSignatureDeclaration {
-        const result: TSSignatureDeclaration = new TSSignatureDeclaration(global.generatedEs2panda._CreateTSSignatureDeclaration(global.context, kind, passNode(signature)))
+        const result: TSSignatureDeclaration = new TSSignatureDeclaration(global.generatedEs2panda._CreateTSSignatureDeclaration(global.context, kind, passNode(signature)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSSignatureDeclaration(original: TSSignatureDeclaration | undefined, kind: Es2pandaTSSignatureDeclarationKind, signature?: FunctionSignature): TSSignatureDeclaration {
-        const result: TSSignatureDeclaration = new TSSignatureDeclaration(global.generatedEs2panda._UpdateTSSignatureDeclaration(global.context, passNode(original), kind, passNode(signature)))
+        const result: TSSignatureDeclaration = new TSSignatureDeclaration(global.generatedEs2panda._UpdateTSSignatureDeclaration(global.context, passNode(original), kind, passNode(signature)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._TSSignatureDeclarationTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSSignatureDeclarationTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
     }
     get params(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._TSSignatureDeclarationParamsConst(global.context, this.peer))
@@ -73,5 +71,5 @@ export function isTSSignatureDeclaration(node: object | undefined): node is TSSi
     return node instanceof TSSignatureDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION, (peer: KNativePointer) => new TSSignatureDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION, (peer: KNativePointer) => new TSSignatureDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION))
 }

package/build/libarkts-copy/src/generated/peers/TSStringKeyword.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 TSStringKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 94)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSStringKeyword(): TSStringKeyword {
-        const result: TSStringKeyword = new TSStringKeyword(global.generatedEs2panda._CreateTSStringKeyword(global.context))
+        const result: TSStringKeyword = new TSStringKeyword(global.generatedEs2panda._CreateTSStringKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSStringKeyword(original?: TSStringKeyword): TSStringKeyword {
-        const result: TSStringKeyword = new TSStringKeyword(global.generatedEs2panda._UpdateTSStringKeyword(global.context, passNode(original)))
+        const result: TSStringKeyword = new TSStringKeyword(global.generatedEs2panda._UpdateTSStringKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isTSStringKeyword(node: object | undefined): node is TSStringKey
     return node instanceof TSStringKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD, (peer: KNativePointer) => new TSStringKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD, (peer: KNativePointer) => new TSStringKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD))
 }

package/build/libarkts-copy/src/generated/peers/TSThisType.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 TSThisType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 118)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSThisType(): TSThisType {
-        const result: TSThisType = new TSThisType(global.generatedEs2panda._CreateTSThisType(global.context))
+        const result: TSThisType = new TSThisType(global.generatedEs2panda._CreateTSThisType(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSThisType(original?: TSThisType): TSThisType {
-        const result: TSThisType = new TSThisType(global.generatedEs2panda._UpdateTSThisType(global.context, passNode(original)))
+        const result: TSThisType = new TSThisType(global.generatedEs2panda._UpdateTSThisType(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isTSThisType(node: object | undefined): node is TSThisType {
     return node instanceof TSThisType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE, (peer: KNativePointer) => new TSThisType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE, (peer: KNativePointer) => new TSThisType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/TSTupleType.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 TSTupleType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 136)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTupleType(elementTypes: readonly TypeNode[]): TSTupleType {
-        const result: TSTupleType = new TSTupleType(global.generatedEs2panda._CreateTSTupleType(global.context, passNodeArray(elementTypes), elementTypes.length))
+        const result: TSTupleType = new TSTupleType(global.generatedEs2panda._CreateTSTupleType(global.context, passNodeArray(elementTypes), elementTypes.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTupleType(original: TSTupleType | undefined, elementTypes: readonly TypeNode[]): TSTupleType {
-        const result: TSTupleType = new TSTupleType(global.generatedEs2panda._UpdateTSTupleType(global.context, passNode(original), passNodeArray(elementTypes), elementTypes.length))
+        const result: TSTupleType = new TSTupleType(global.generatedEs2panda._UpdateTSTupleType(global.context, passNode(original), passNodeArray(elementTypes), elementTypes.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isTSTupleType(node: object | undefined): node is TSTupleType {
     return node instanceof TSTupleType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE, (peer: KNativePointer) => new TSTupleType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE, (peer: KNativePointer) => new TSTupleType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -34,20 +33,19 @@ import {
 import { AnnotatedStatement } from "./AnnotatedStatement"
 import { AnnotationUsage } from "./AnnotationUsage"
-import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
+import { SrcDumper } from "./SrcDumper"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 export class TSTypeAliasDeclaration extends AnnotatedStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 129)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
-        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration(global.context, passNode(id), passNode(typeParams), passNode(typeAnnotation)))
+        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration(global.context, passNode(id), passNode(typeParams), passNode(typeAnnotation)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -60,7 +58,7 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement {
         return result
     }
     static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
-        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration(global.context, passNode(original), passNode(id), passNode(typeParams), passNode(typeAnnotation)))
+        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration(global.context, passNode(original), passNode(id), passNode(typeParams), passNode(typeAnnotation)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -73,7 +71,7 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement {
         return result
     }
     static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
-        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration1(global.context, passNode(original), passNode(id)))
+        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration1(global.context, passNode(original), passNode(id)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -86,30 +84,35 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement {
         return result
     }
     get id(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationId(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationId(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeParamsConst(global.context, this.peer))
-    }
-    get decorators(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationDecoratorsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeParamsConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
     }
     /** @deprecated */
     setTypeParameters(typeParams?: TSTypeParameterDeclaration): this {
         global.generatedEs2panda._TSTypeAliasDeclarationSetTypeParameters(global.context, this.peer, passNode(typeParams))
         return this
     }
-    get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationAnnotationsConst(global.context, this.peer))
+    /** @deprecated */
+    clearTypeParamterTypes(): this {
+        global.generatedEs2panda._TSTypeAliasDeclarationClearTypeParamterTypes(global.context, this.peer)
+        return this
+    }
+    get typeAnnotation(): TypeNode {
+        return unpackNonNullableNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeAnnotationConst(global.context, this.peer))
     }
     /** @deprecated */
-    setAnnotations(annotations: readonly AnnotationUsage[]): this {
-        global.generatedEs2panda._TSTypeAliasDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+    setTsTypeAnnotation(typeAnnotation?: TypeNode): this {
+        global.generatedEs2panda._TSTypeAliasDeclarationSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
         return this
     }
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._TSTypeAliasDeclarationHasAnnotationsConst(global.context, this.peer)
+    }
     /** @deprecated */
-    emplaceAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._TSTypeAliasDeclarationEmplaceAnnotations(global.context, this.peer, passNode(annotations))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._TSTypeAliasDeclarationEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -118,42 +121,24 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(annotations: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._TSTypeAliasDeclarationSetValueAnnotations(global.context, this.peer, passNode(annotations), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._TSTypeAliasDeclarationDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
-    /** @deprecated */
-    clearTypeParamterTypes(): this {
-        global.generatedEs2panda._TSTypeAliasDeclarationClearTypeParamterTypes(global.context, this.peer)
-        return this
-    }
-    /** @deprecated */
-    emplaceDecorators(decorators?: Decorator): this {
-        global.generatedEs2panda._TSTypeAliasDeclarationEmplaceDecorators(global.context, this.peer, passNode(decorators))
-        return this
-    }
-    /** @deprecated */
-    clearDecorators(): this {
-        global.generatedEs2panda._TSTypeAliasDeclarationClearDecorators(global.context, this.peer)
-        return this
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
-    setValueDecorators(decorators: Decorator | undefined, index: number): this {
-        global.generatedEs2panda._TSTypeAliasDeclarationSetValueDecorators(global.context, this.peer, passNode(decorators), index)
+    setAnnotations(annotationList: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._TSTypeAliasDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    get decoratorsForUpdate(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationDecoratorsForUpdate(global.context, this.peer))
-    }
-    get typeAnnotation(): TypeNode {
-        return unpackNonNullableNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeAnnotationConst(global.context, this.peer))
-    }
     /** @deprecated */
-    setTsTypeAnnotation(typeAnnotation?: TypeNode): this {
-        global.generatedEs2panda._TSTypeAliasDeclarationSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
+    setAnnotations1(annotationList: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._TSTypeAliasDeclarationSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
     protected readonly brandTSTypeAliasDeclaration: undefined
@@ -162,5 +147,5 @@ export function isTSTypeAliasDeclaration(node: object | undefined): node is TSTy
     return node instanceof TSTypeAliasDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION, (peer: KNativePointer) => new TSTypeAliasDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION, (peer: KNativePointer) => new TSTypeAliasDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION))
 }

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

@@ -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 TSTypeAssertion extends AnnotatedExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 142)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion {
-        const result: TSTypeAssertion = new TSTypeAssertion(global.generatedEs2panda._CreateTSTypeAssertion(global.context, passNode(typeAnnotation), passNode(expression)))
+        const result: TSTypeAssertion = new TSTypeAssertion(global.generatedEs2panda._CreateTSTypeAssertion(global.context, passNode(typeAnnotation), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeAssertion(original?: TSTypeAssertion, typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion {
-        const result: TSTypeAssertion = new TSTypeAssertion(global.generatedEs2panda._UpdateTSTypeAssertion(global.context, passNode(original), passNode(typeAnnotation), passNode(expression)))
+        const result: TSTypeAssertion = new TSTypeAssertion(global.generatedEs2panda._UpdateTSTypeAssertion(global.context, passNode(original), passNode(typeAnnotation), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION)
         result.setChildrenParentPtr()
         return result
     }
@@ -69,5 +67,5 @@ export function isTSTypeAssertion(node: object | undefined): node is TSTypeAsser
     return node instanceof TSTypeAssertion
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION, (peer: KNativePointer) => new TSTypeAssertion(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION, (peer: KNativePointer) => new TSTypeAssertion(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION))
 }

package/build/libarkts-copy/src/generated/peers/TSTypeLiteral.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 TSTypeLiteral extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 106)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeLiteral(members: readonly AstNode[]): TSTypeLiteral {
-        const result: TSTypeLiteral = new TSTypeLiteral(global.generatedEs2panda._CreateTSTypeLiteral(global.context, passNodeArray(members), members.length))
+        const result: TSTypeLiteral = new TSTypeLiteral(global.generatedEs2panda._CreateTSTypeLiteral(global.context, passNodeArray(members), members.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeLiteral(original: TSTypeLiteral | undefined, members: readonly AstNode[]): TSTypeLiteral {
-        const result: TSTypeLiteral = new TSTypeLiteral(global.generatedEs2panda._UpdateTSTypeLiteral(global.context, passNode(original), passNodeArray(members), members.length))
+        const result: TSTypeLiteral = new TSTypeLiteral(global.generatedEs2panda._UpdateTSTypeLiteral(global.context, passNode(original), passNodeArray(members), members.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isTSTypeLiteral(node: object | undefined): node is TSTypeLiteral
     return node instanceof TSTypeLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL, (peer: KNativePointer) => new TSTypeLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL, (peer: KNativePointer) => new TSTypeLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL))
 }