@idlizer/arktscgen 2.1.2

package/build/libarkts-copy/src/generated/peers/DebuggerStatement.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 { Statement } from "./Statement"
+export class DebuggerStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 21)
+        super(pointer)
+    }
+    static createDebuggerStatement(): DebuggerStatement {
+        return new DebuggerStatement(global.generatedEs2panda._CreateDebuggerStatement(global.context))
+    }
+    static updateDebuggerStatement(original?: DebuggerStatement): DebuggerStatement {
+        return new DebuggerStatement(global.generatedEs2panda._UpdateDebuggerStatement(global.context, passNode(original)))
+    }
+}
+export function isDebuggerStatement(node: object | undefined): node is DebuggerStatement {
+    return node instanceof DebuggerStatement
+}
+if (!nodeByType.has(21)) {
+    nodeByType.set(21, DebuggerStatement)
+}

package/build/libarkts-copy/src/generated/peers/Decorator.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 { Expression } from "./Expression"
+import { Statement } from "./Statement"
+export class Decorator extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 22)
+        super(pointer)
+    }
+    static createDecorator(expr?: Expression): Decorator {
+        return new Decorator(global.generatedEs2panda._CreateDecorator(global.context, passNode(expr)))
+    }
+    static updateDecorator(original?: Decorator, expr?: Expression): Decorator {
+        return new Decorator(global.generatedEs2panda._UpdateDecorator(global.context, passNode(original), passNode(expr)))
+    }
+    get expr(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._DecoratorExprConst(global.context, this.peer))
+    }
+}
+export function isDecorator(node: object | undefined): node is Decorator {
+    return node instanceof Decorator
+}
+if (!nodeByType.has(22)) {
+    nodeByType.set(22, Decorator)
+}

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

@@ -0,0 +1,52 @@
+/*
+ * 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 { CallExpression } from "./CallExpression"
+import { Expression } from "./Expression"
+import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
+export class DirectEvalExpression extends CallExpression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 23)
+        super(pointer)
+    }
+    static createDirectEvalExpression(callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression {
+        return new DirectEvalExpression(global.generatedEs2panda._CreateDirectEvalExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus))
+    }
+    static updateDirectEvalExpression(original: DirectEvalExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression {
+        return new DirectEvalExpression(global.generatedEs2panda._UpdateDirectEvalExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus))
+    }
+}
+export function isDirectEvalExpression(node: object | undefined): node is DirectEvalExpression {
+    return node instanceof DirectEvalExpression
+}
+if (!nodeByType.has(23)) {
+    nodeByType.set(23, DirectEvalExpression)
+}

package/build/libarkts-copy/src/generated/peers/DoWhileStatement.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 { Expression } from "./Expression"
+import { LoopStatement } from "./LoopStatement"
+import { Statement } from "./Statement"
+export class DoWhileStatement extends LoopStatement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 24)
+        super(pointer)
+    }
+    static createDoWhileStatement(body?: Statement, test?: Expression): DoWhileStatement {
+        return new DoWhileStatement(global.generatedEs2panda._CreateDoWhileStatement(global.context, passNode(body), passNode(test)))
+    }
+    static updateDoWhileStatement(original?: DoWhileStatement, body?: Statement, test?: Expression): DoWhileStatement {
+        return new DoWhileStatement(global.generatedEs2panda._UpdateDoWhileStatement(global.context, passNode(original), passNode(body), passNode(test)))
+    }
+    get body(): Statement | undefined {
+        return unpackNode(global.generatedEs2panda._DoWhileStatementBodyConst(global.context, this.peer))
+    }
+    get test(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._DoWhileStatementTestConst(global.context, this.peer))
+    }
+}
+export function isDoWhileStatement(node: object | undefined): node is DoWhileStatement {
+    return node instanceof DoWhileStatement
+}
+if (!nodeByType.has(24)) {
+    nodeByType.set(24, DoWhileStatement)
+}

package/build/libarkts-copy/src/generated/peers/ETSClassLiteral.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 { Expression } from "./Expression"
+import { TypeNode } from "./TypeNode"
+export class ETSClassLiteral extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 70)
+        super(pointer)
+    }
+    static createETSClassLiteral(expr?: TypeNode): ETSClassLiteral {
+        return new ETSClassLiteral(global.generatedEs2panda._CreateETSClassLiteral(global.context, passNode(expr)))
+    }
+    static updateETSClassLiteral(original?: ETSClassLiteral, expr?: TypeNode): ETSClassLiteral {
+        return new ETSClassLiteral(global.generatedEs2panda._UpdateETSClassLiteral(global.context, passNode(original), passNode(expr)))
+    }
+    get expr(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ETSClassLiteralExprConst(global.context, this.peer))
+    }
+}
+export function isETSClassLiteral(node: object | undefined): node is ETSClassLiteral {
+    return node instanceof ETSClassLiteral
+}
+if (!nodeByType.has(70)) {
+    nodeByType.set(70, ETSClassLiteral)
+}

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

@@ -0,0 +1,40 @@
+/*
+ * 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 { ETSFunctionType } from "./ETSFunctionType"
+export class ETSDynamicFunctionType extends ETSFunctionType {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}
+export function isETSDynamicFunctionType(node: object | undefined): node is ETSDynamicFunctionType {
+    return node instanceof ETSDynamicFunctionType
+}

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

@@ -0,0 +1,84 @@
+/*
+ * 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 { Es2pandaScriptFunctionFlags } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { FunctionSignature } from "./FunctionSignature"
+import { TSInterfaceDeclaration } from "./TSInterfaceDeclaration"
+import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
+import { TypeNode } from "./TypeNode"
+export class ETSFunctionType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 66)
+        super(pointer)
+    }
+    static createETSFunctionType(signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags): ETSFunctionType {
+        return new ETSFunctionType(global.generatedEs2panda._CreateETSFunctionTypeIr(global.context, passNode(signature), funcFlags))
+    }
+    static updateETSFunctionType(original: ETSFunctionType | undefined, signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags): ETSFunctionType {
+        return new ETSFunctionType(global.generatedEs2panda._UpdateETSFunctionTypeIr(global.context, passNode(original), passNode(signature), funcFlags))
+    }
+    get typeParams(): TSTypeParameterDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrTypeParamsConst(global.context, this.peer))
+    }
+    get params(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._ETSFunctionTypeIrParamsConst(global.context, this.peer))
+    }
+    get returnType(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrReturnTypeConst(global.context, this.peer))
+    }
+    get functionalInterface(): TSInterfaceDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._ETSFunctionTypeIrFunctionalInterfaceConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setFunctionalInterface(functionalInterface?: TSInterfaceDeclaration): this {
+        global.generatedEs2panda._ETSFunctionTypeIrSetFunctionalInterface(global.context, this.peer, passNode(functionalInterface))
+        return this
+    }
+    get flags(): Es2pandaScriptFunctionFlags {
+        return global.generatedEs2panda._ETSFunctionTypeIrFlags(global.context, this.peer)
+    }
+    get isThrowing(): boolean {
+        return global.generatedEs2panda._ETSFunctionTypeIrIsThrowingConst(global.context, this.peer)
+    }
+    get isRethrowing(): boolean {
+        return global.generatedEs2panda._ETSFunctionTypeIrIsRethrowingConst(global.context, this.peer)
+    }
+    get isExtensionFunction(): boolean {
+        return global.generatedEs2panda._ETSFunctionTypeIrIsExtensionFunctionConst(global.context, this.peer)
+    }
+}
+export function isETSFunctionType(node: object | undefined): node is ETSFunctionType {
+    return node instanceof ETSFunctionType
+}
+if (!nodeByType.has(66)) {
+    nodeByType.set(66, ETSFunctionType)
+}

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

@@ -0,0 +1,68 @@
+/*
+ * 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 { Es2pandaImportKinds } from "./../Es2pandaEnums"
+import { ImportDeclaration } from "./ImportDeclaration"
+import { ImportSource } from "./ImportSource"
+import { StringLiteral } from "./StringLiteral"
+export class ETSImportDeclaration extends ImportDeclaration {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 78)
+        super(pointer)
+    }
+    static createETSImportDeclaration(source: ImportSource | undefined, specifiers: readonly AstNode[], importKind: Es2pandaImportKinds): ETSImportDeclaration {
+        return new ETSImportDeclaration(global.generatedEs2panda._CreateETSImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length, importKind))
+    }
+    static updateETSImportDeclaration(original: ETSImportDeclaration | undefined, source: ImportSource | undefined, specifiers: readonly AstNode[], importKind: Es2pandaImportKinds): ETSImportDeclaration {
+        return new ETSImportDeclaration(global.generatedEs2panda._UpdateETSImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length, importKind))
+    }
+    get hasDecl(): boolean {
+        return global.generatedEs2panda._ETSImportDeclarationHasDeclConst(global.context, this.peer)
+    }
+    get isPureDynamic(): boolean {
+        return global.generatedEs2panda._ETSImportDeclarationIsPureDynamicConst(global.context, this.peer)
+    }
+    get assemblerName(): string {
+        return unpackString(global.generatedEs2panda._ETSImportDeclarationAssemblerNameConst(global.context, this.peer))
+    }
+    get source(): StringLiteral | undefined {
+        return unpackNode(global.generatedEs2panda._ETSImportDeclarationSourceConst(global.context, this.peer))
+    }
+    get resolvedSource(): StringLiteral | undefined {
+        return unpackNode(global.generatedEs2panda._ETSImportDeclarationResolvedSourceConst(global.context, this.peer))
+    }
+}
+export function isETSImportDeclaration(node: object | undefined): node is ETSImportDeclaration {
+    return node instanceof ETSImportDeclaration
+}
+if (!nodeByType.has(78)) {
+    nodeByType.set(78, ETSImportDeclaration)
+}

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

@@ -0,0 +1,57 @@
+/*
+ * 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 { CallExpression } from "./CallExpression"
+import { Expression } from "./Expression"
+export class ETSLaunchExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 74)
+        super(pointer)
+    }
+    static createETSLaunchExpression(expr?: CallExpression): ETSLaunchExpression {
+        return new ETSLaunchExpression(global.generatedEs2panda._CreateETSLaunchExpression(global.context, passNode(expr)))
+    }
+    static updateETSLaunchExpression(original?: ETSLaunchExpression, expr?: CallExpression): ETSLaunchExpression {
+        return new ETSLaunchExpression(global.generatedEs2panda._UpdateETSLaunchExpression(global.context, passNode(original), passNode(expr)))
+    }
+    get isStaticCall(): boolean {
+        return global.generatedEs2panda._ETSLaunchExpressionIsStaticCallConst(global.context, this.peer)
+    }
+    get call(): CallExpression | undefined {
+        return unpackNode(global.generatedEs2panda._ETSLaunchExpressionCallConst(global.context, this.peer))
+    }
+}
+export function isETSLaunchExpression(node: object | undefined): node is ETSLaunchExpression {
+    return node instanceof ETSLaunchExpression
+}
+if (!nodeByType.has(74)) {
+    nodeByType.set(74, ETSLaunchExpression)
+}

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

@@ -0,0 +1,71 @@
+/*
+ * 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 { AnnotationUsage } from "./AnnotationUsage"
+import { BlockStatement } from "./BlockStatement"
+import { Identifier } from "./Identifier"
+export class ETSModule extends BlockStatement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 81)
+        super(pointer)
+    }
+    get ident(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ETSModuleIdentConst(global.context, this.peer))
+    }
+    get isETSScript(): boolean {
+        return global.generatedEs2panda._ETSModuleIsETSScriptConst(global.context, this.peer)
+    }
+    get isNamespace(): boolean {
+        return global.generatedEs2panda._ETSModuleIsNamespaceConst(global.context, this.peer)
+    }
+    get isNamespaceChainLastNode(): boolean {
+        return global.generatedEs2panda._ETSModuleIsNamespaceChainLastNodeConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setNamespaceChainLastNode(): this {
+        global.generatedEs2panda._ETSModuleSetNamespaceChainLastNode(global.context, this.peer)
+        return this
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._ETSModuleAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._ETSModuleSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isETSModule(node: object | undefined): node is ETSModule {
+    return node instanceof ETSModule
+}
+if (!nodeByType.has(81)) {
+    nodeByType.set(81, ETSModule)
+}

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

@@ -0,0 +1,62 @@
+/*
+ * 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 ETSNewArrayInstanceExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 75)
+        super(pointer)
+    }
+    static createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression {
+        return new ETSNewArrayInstanceExpression(global.generatedEs2panda._CreateETSNewArrayInstanceExpression(global.context, passNode(typeReference), passNode(dimension)))
+    }
+    static updateETSNewArrayInstanceExpression(original?: ETSNewArrayInstanceExpression, typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression {
+        return new ETSNewArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNode(dimension)))
+    }
+    get typeReference(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionTypeReferenceConst(global.context, this.peer))
+    }
+    get dimension(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionDimensionConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setDimension(dimension?: Expression): this {
+        global.generatedEs2panda._ETSNewArrayInstanceExpressionSetDimension(global.context, this.peer, passNode(dimension))
+        return this
+    }
+}
+export function isETSNewArrayInstanceExpression(node: object | undefined): node is ETSNewArrayInstanceExpression {
+    return node instanceof ETSNewArrayInstanceExpression
+}
+if (!nodeByType.has(75)) {
+    nodeByType.set(75, ETSNewArrayInstanceExpression)
+}