@idlizer/arktscgen 2.1.2

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { Expression } from "./Expression"
+export class ETSNewClassInstanceExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 77)
+        super(pointer)
+    }
+    static createETSNewClassInstanceExpression(typeReference: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression {
+        return new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression(global.context, passNode(typeReference), passNodeArray(_arguments), _arguments.length))
+    }
+    static updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression | undefined, typeReference: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression {
+        return new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(_arguments), _arguments.length))
+    }
+    static update1ETSNewClassInstanceExpression(original?: ETSNewClassInstanceExpression, other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression {
+        return new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression1(global.context, passNode(original), passNode(other)))
+    }
+    get typeRef(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ETSNewClassInstanceExpressionGetTypeRefConst(global.context, this.peer))
+    }
+    get arguments(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._ETSNewClassInstanceExpressionGetArgumentsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setArguments(_arguments: readonly Expression[]): this {
+        global.generatedEs2panda._ETSNewClassInstanceExpressionSetArguments(global.context, this.peer, passNodeArray(_arguments), _arguments.length)
+        return this
+    }
+    /** @deprecated */
+    addToArgumentsFront(expr?: Expression): this {
+        global.generatedEs2panda._ETSNewClassInstanceExpressionAddToArgumentsFront(global.context, this.peer, passNode(expr))
+        return this
+    }
+}
+export function isETSNewClassInstanceExpression(node: object | undefined): node is ETSNewClassInstanceExpression {
+    return node instanceof ETSNewClassInstanceExpression
+}
+if (!nodeByType.has(77)) {
+    nodeByType.set(77, ETSNewClassInstanceExpression)
+}

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

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { Expression } from "./Expression"
+import { TypeNode } from "./TypeNode"
+export class ETSNewMultiDimArrayInstanceExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 76)
+        super(pointer)
+    }
+    static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression {
+        return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression(global.context, passNode(typeReference), passNodeArray(dimensions), dimensions.length))
+    }
+    static updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression | undefined, typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression {
+        return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(dimensions), dimensions.length))
+    }
+    static update1ETSNewMultiDimArrayInstanceExpression(original?: ETSNewMultiDimArrayInstanceExpression, other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression {
+        return new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(original), passNode(other)))
+    }
+    get typeReference(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionTypeReferenceConst(global.context, this.peer))
+    }
+    get dimensions(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionDimensionsConst(global.context, this.peer))
+    }
+}
+export function isETSNewMultiDimArrayInstanceExpression(node: object | undefined): node is ETSNewMultiDimArrayInstanceExpression {
+    return node instanceof ETSNewMultiDimArrayInstanceExpression
+}
+if (!nodeByType.has(76)) {
+    nodeByType.set(76, ETSNewMultiDimArrayInstanceExpression)
+}

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

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { TypeNode } from "./TypeNode"
+export class ETSNullType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 62)
+        super(pointer)
+    }
+    static createETSNullType(): ETSNullType {
+        return new ETSNullType(global.generatedEs2panda._CreateETSNullTypeIr(global.context))
+    }
+    static updateETSNullType(original?: ETSNullType): ETSNullType {
+        return new ETSNullType(global.generatedEs2panda._UpdateETSNullTypeIr(global.context, passNode(original)))
+    }
+}
+export function isETSNullType(node: object | undefined): node is ETSNullType {
+    return node instanceof ETSNullType
+}
+if (!nodeByType.has(62)) {
+    nodeByType.set(62, ETSNullType)
+}

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { Expression } from "./Expression"
+import { Statement } from "./Statement"
+export class ETSPackageDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 69)
+        super(pointer)
+    }
+    static createETSPackageDeclaration(name?: Expression): ETSPackageDeclaration {
+        return new ETSPackageDeclaration(global.generatedEs2panda._CreateETSPackageDeclaration(global.context, passNode(name)))
+    }
+    static updateETSPackageDeclaration(original?: ETSPackageDeclaration, name?: Expression): ETSPackageDeclaration {
+        return new ETSPackageDeclaration(global.generatedEs2panda._UpdateETSPackageDeclaration(global.context, passNode(original), passNode(name)))
+    }
+}
+export function isETSPackageDeclaration(node: object | undefined): node is ETSPackageDeclaration {
+    return node instanceof ETSPackageDeclaration
+}
+if (!nodeByType.has(69)) {
+    nodeByType.set(69, ETSPackageDeclaration)
+}

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

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { AnnotatedExpression } from "./AnnotatedExpression"
+import { AnnotationUsage } from "./AnnotationUsage"
+import { Expression } from "./Expression"
+import { Identifier } from "./Identifier"
+import { SpreadElement } from "./SpreadElement"
+import { TypeNode } from "./TypeNode"
+export class ETSParameterExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 79)
+        super(pointer)
+    }
+    static createETSParameterExpression(identOrSpread: AnnotatedExpression | undefined, isOptional: boolean): ETSParameterExpression {
+        return new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression(global.context, passNode(identOrSpread), isOptional))
+    }
+    static updateETSParameterExpression(original: ETSParameterExpression | undefined, identOrSpread: AnnotatedExpression | undefined, isOptional: boolean): ETSParameterExpression {
+        return new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression(global.context, passNode(original), passNode(identOrSpread), isOptional))
+    }
+    static create1ETSParameterExpression(identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression {
+        return new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression1(global.context, passNode(identOrSpread), passNode(initializer)))
+    }
+    static update1ETSParameterExpression(original?: ETSParameterExpression, identOrSpread?: AnnotatedExpression, initializer?: Expression): ETSParameterExpression {
+        return new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression1(global.context, passNode(original), passNode(identOrSpread), passNode(initializer)))
+    }
+    get name(): string {
+        return unpackString(global.generatedEs2panda._ETSParameterExpressionNameConst(global.context, this.peer))
+    }
+    get ident(): Identifier {
+        return unpackNonNullableNode(global.generatedEs2panda._ETSParameterExpressionIdentConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setIdent(ident?: Identifier): this {
+        global.generatedEs2panda._ETSParameterExpressionSetIdent(global.context, this.peer, passNode(ident))
+        return this
+    }
+    get restParameter(): SpreadElement | undefined {
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionRestParameterConst(global.context, this.peer))
+    }
+    get initializer(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionInitializerConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setLexerSaved(s: string): this {
+        global.generatedEs2panda._ETSParameterExpressionSetLexerSaved(global.context, this.peer, s)
+        return this
+    }
+    get lexerSaved(): string {
+        return unpackString(global.generatedEs2panda._ETSParameterExpressionLexerSavedConst(global.context, this.peer))
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTypeAnnotation(typeNode?: TypeNode): this {
+        global.generatedEs2panda._ETSParameterExpressionSetTypeAnnotation(global.context, this.peer, passNode(typeNode))
+        return this
+    }
+    get isOptional(): boolean {
+        return global.generatedEs2panda._ETSParameterExpressionIsOptionalConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setOptional(value: boolean): this {
+        global.generatedEs2panda._ETSParameterExpressionSetOptional(global.context, this.peer, value)
+        return this
+    }
+    /** @deprecated */
+    setInitializer(initExpr?: Expression): this {
+        global.generatedEs2panda._ETSParameterExpressionSetInitializer(global.context, this.peer, passNode(initExpr))
+        return this
+    }
+    get isRestParameter(): boolean {
+        return global.generatedEs2panda._ETSParameterExpressionIsRestParameterConst(global.context, this.peer)
+    }
+    get requiredParams(): number {
+        return global.generatedEs2panda._ETSParameterExpressionGetRequiredParamsConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setRequiredParams(value: number): this {
+        global.generatedEs2panda._ETSParameterExpressionSetRequiredParams(global.context, this.peer, value)
+        return this
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._ETSParameterExpressionAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._ETSParameterExpressionSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isETSParameterExpression(node: object | undefined): node is ETSParameterExpression {
+    return node instanceof ETSParameterExpression
+}
+if (!nodeByType.has(79)) {
+    nodeByType.set(79, ETSParameterExpression)
+}

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

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { Es2pandaPrimitiveType } from "./../Es2pandaEnums"
+import { TypeNode } from "./TypeNode"
+export class ETSPrimitiveType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 68)
+        super(pointer)
+    }
+    static createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType {
+        return new ETSPrimitiveType(global.generatedEs2panda._CreateETSPrimitiveType(global.context, type))
+    }
+    static updateETSPrimitiveType(original: ETSPrimitiveType | undefined, type: Es2pandaPrimitiveType): ETSPrimitiveType {
+        return new ETSPrimitiveType(global.generatedEs2panda._UpdateETSPrimitiveType(global.context, passNode(original), type))
+    }
+    get primitiveType(): Es2pandaPrimitiveType {
+        return global.generatedEs2panda._ETSPrimitiveTypeGetPrimitiveTypeConst(global.context, this.peer)
+    }
+}
+export function isETSPrimitiveType(node: object | undefined): node is ETSPrimitiveType {
+    return node instanceof ETSPrimitiveType
+}
+if (!nodeByType.has(68)) {
+    nodeByType.set(68, ETSPrimitiveType)
+}

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { ETSImportDeclaration } from "./ETSImportDeclaration"
+import { Statement } from "./Statement"
+export class ETSReExportDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 57)
+        super(pointer)
+    }
+    get eTSImportDeclarations(): ETSImportDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._ETSReExportDeclarationGetETSImportDeclarationsConst(global.context, this.peer))
+    }
+    get programPath(): string {
+        return unpackString(global.generatedEs2panda._ETSReExportDeclarationGetProgramPathConst(global.context, this.peer))
+    }
+}
+export function isETSReExportDeclaration(node: object | undefined): node is ETSReExportDeclaration {
+    return node instanceof ETSReExportDeclaration
+}
+if (!nodeByType.has(57)) {
+    nodeByType.set(57, ETSReExportDeclaration)
+}

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { ClassDeclaration } from "./ClassDeclaration"
+import { ClassDefinition } from "./ClassDefinition"
+export class ETSStructDeclaration extends ClassDeclaration {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 83)
+        super(pointer)
+    }
+    static createETSStructDeclaration(def?: ClassDefinition): ETSStructDeclaration {
+        return new ETSStructDeclaration(global.generatedEs2panda._CreateETSStructDeclaration(global.context, passNode(def)))
+    }
+    static updateETSStructDeclaration(original?: ETSStructDeclaration, def?: ClassDefinition): ETSStructDeclaration {
+        return new ETSStructDeclaration(global.generatedEs2panda._UpdateETSStructDeclaration(global.context, passNode(original), passNode(def)))
+    }
+}
+export function isETSStructDeclaration(node: object | undefined): node is ETSStructDeclaration {
+    return node instanceof ETSStructDeclaration
+}
+if (!nodeByType.has(83)) {
+    nodeByType.set(83, ETSStructDeclaration)
+}

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { TypeNode } from "./TypeNode"
+export class ETSTuple extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 80)
+        super(pointer)
+    }
+    static createETSTuple(): ETSTuple {
+        return new ETSTuple(global.generatedEs2panda._CreateETSTuple(global.context))
+    }
+    static updateETSTuple(original?: ETSTuple): ETSTuple {
+        return new ETSTuple(global.generatedEs2panda._UpdateETSTuple(global.context, passNode(original)))
+    }
+    static create1ETSTuple(size: number): ETSTuple {
+        return new ETSTuple(global.generatedEs2panda._CreateETSTuple1(global.context, size))
+    }
+    static update1ETSTuple(original: ETSTuple | undefined, size: number): ETSTuple {
+        return new ETSTuple(global.generatedEs2panda._UpdateETSTuple1(global.context, passNode(original), size))
+    }
+    static create2ETSTuple(typeList: readonly TypeNode[]): ETSTuple {
+        return new ETSTuple(global.generatedEs2panda._CreateETSTuple2(global.context, passNodeArray(typeList), typeList.length))
+    }
+    static update2ETSTuple(original: ETSTuple | undefined, typeList: readonly TypeNode[]): ETSTuple {
+        return new ETSTuple(global.generatedEs2panda._UpdateETSTuple2(global.context, passNode(original), passNodeArray(typeList), typeList.length))
+    }
+    get tupleSize(): number {
+        return global.generatedEs2panda._ETSTupleGetTupleSizeConst(global.context, this.peer)
+    }
+    get tupleTypeAnnotationsList(): readonly TypeNode[] {
+        return unpackNodeArray(global.generatedEs2panda._ETSTupleGetTupleTypeAnnotationsListConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTypeAnnotationsList(typeNodeList: readonly TypeNode[]): this {
+        global.generatedEs2panda._ETSTupleSetTypeAnnotationsList(global.context, this.peer, passNodeArray(typeNodeList), typeNodeList.length)
+        return this
+    }
+}
+export function isETSTuple(node: object | undefined): node is ETSTuple {
+    return node instanceof ETSTuple
+}
+if (!nodeByType.has(80)) {
+    nodeByType.set(80, ETSTuple)
+}

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { ETSTypeReferencePart } from "./ETSTypeReferencePart"
+import { Identifier } from "./Identifier"
+import { TypeNode } from "./TypeNode"
+export class ETSTypeReference extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 71)
+        super(pointer)
+    }
+    static createETSTypeReference(part?: ETSTypeReferencePart): ETSTypeReference {
+        return new ETSTypeReference(global.generatedEs2panda._CreateETSTypeReference(global.context, passNode(part)))
+    }
+    static updateETSTypeReference(original?: ETSTypeReference, part?: ETSTypeReferencePart): ETSTypeReference {
+        return new ETSTypeReference(global.generatedEs2panda._UpdateETSTypeReference(global.context, passNode(original), passNode(part)))
+    }
+    get part(): ETSTypeReferencePart | undefined {
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartConst(global.context, this.peer))
+    }
+    get baseName(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ETSTypeReferenceBaseNameConst(global.context, this.peer))
+    }
+}
+export function isETSTypeReference(node: object | undefined): node is ETSTypeReference {
+    return node instanceof ETSTypeReference
+}
+if (!nodeByType.has(71)) {
+    nodeByType.set(71, ETSTypeReference)
+}