@idlizer/arktscgen 2.1.2

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

@@ -0,0 +1,53 @@
+/*
+ * 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 TSInterfaceBody extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 131)
+        super(pointer)
+    }
+    static createTSInterfaceBody(body: readonly AstNode[]): TSInterfaceBody {
+        return new TSInterfaceBody(global.generatedEs2panda._CreateTSInterfaceBody(global.context, passNodeArray(body), body.length))
+    }
+    static updateTSInterfaceBody(original: TSInterfaceBody | undefined, body: readonly AstNode[]): TSInterfaceBody {
+        return new TSInterfaceBody(global.generatedEs2panda._UpdateTSInterfaceBody(global.context, passNode(original), passNodeArray(body), body.length))
+    }
+    get body(): readonly AstNode[] {
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceBodyBodyConst(global.context, this.peer))
+    }
+}
+export function isTSInterfaceBody(node: object | undefined): node is TSInterfaceBody {
+    return node instanceof TSInterfaceBody
+}
+if (!nodeByType.has(131)) {
+    nodeByType.set(131, TSInterfaceBody)
+}

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

@@ -0,0 +1,102 @@
+/*
+ * 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 { ClassDeclaration } from "./ClassDeclaration"
+import { Decorator } from "./Decorator"
+import { Identifier } from "./Identifier"
+import { TSInterfaceBody } from "./TSInterfaceBody"
+import { TSInterfaceHeritage } from "./TSInterfaceHeritage"
+import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
+import { TypedStatement } from "./TypedStatement"
+export class TSInterfaceDeclaration extends TypedStatement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 130)
+        super(pointer)
+    }
+    static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration {
+        return new TSInterfaceDeclaration(global.generatedEs2panda._CreateTSInterfaceDeclaration(global.context, passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal))
+    }
+    static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration | undefined, _extends: readonly TSInterfaceHeritage[], id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean): TSInterfaceDeclaration {
+        return new TSInterfaceDeclaration(global.generatedEs2panda._UpdateTSInterfaceDeclaration(global.context, passNode(original), passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal))
+    }
+    get body(): TSInterfaceBody | undefined {
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationBodyConst(global.context, this.peer))
+    }
+    get id(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationIdConst(global.context, this.peer))
+    }
+    get internalName(): string {
+        return unpackString(global.generatedEs2panda._TSInterfaceDeclarationInternalNameConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setInternalName(internalName: string): this {
+        global.generatedEs2panda._TSInterfaceDeclarationSetInternalName(global.context, this.peer, internalName)
+        return this
+    }
+    get isStatic(): boolean {
+        return global.generatedEs2panda._TSInterfaceDeclarationIsStaticConst(global.context, this.peer)
+    }
+    get isFromExternal(): boolean {
+        return global.generatedEs2panda._TSInterfaceDeclarationIsFromExternalConst(global.context, this.peer)
+    }
+    get typeParams(): TSTypeParameterDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationTypeParamsConst(global.context, this.peer))
+    }
+    get extends(): readonly TSInterfaceHeritage[] {
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationExtendsConst(global.context, this.peer))
+    }
+    get decorators(): readonly Decorator[] {
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationDecoratorsConst(global.context, this.peer))
+    }
+    get anonClass(): ClassDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationGetAnonClassConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnonClass(anonClass?: ClassDeclaration): this {
+        global.generatedEs2panda._TSInterfaceDeclarationSetAnonClass(global.context, this.peer, passNode(anonClass))
+        return this
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._TSInterfaceDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isTSInterfaceDeclaration(node: object | undefined): node is TSInterfaceDeclaration {
+    return node instanceof TSInterfaceDeclaration
+}
+if (!nodeByType.has(130)) {
+    nodeByType.set(130, TSInterfaceDeclaration)
+}

package/build/libarkts-copy/src/generated/peers/TSInterfaceHeritage.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 TSInterfaceHeritage extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 132)
+        super(pointer)
+    }
+    static createTSInterfaceHeritage(expr?: TypeNode): TSInterfaceHeritage {
+        return new TSInterfaceHeritage(global.generatedEs2panda._CreateTSInterfaceHeritage(global.context, passNode(expr)))
+    }
+    static updateTSInterfaceHeritage(original?: TSInterfaceHeritage, expr?: TypeNode): TSInterfaceHeritage {
+        return new TSInterfaceHeritage(global.generatedEs2panda._UpdateTSInterfaceHeritage(global.context, passNode(original), passNode(expr)))
+    }
+    get expr(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSInterfaceHeritageExprConst(global.context, this.peer))
+    }
+}
+export function isTSInterfaceHeritage(node: object | undefined): node is TSInterfaceHeritage {
+    return node instanceof TSInterfaceHeritage
+}
+if (!nodeByType.has(132)) {
+    nodeByType.set(132, TSInterfaceHeritage)
+}

package/build/libarkts-copy/src/generated/peers/TSIntersectionType.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 TSIntersectionType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 112)
+        super(pointer)
+    }
+    static createTSIntersectionType(types: readonly Expression[]): TSIntersectionType {
+        return new TSIntersectionType(global.generatedEs2panda._CreateTSIntersectionType(global.context, passNodeArray(types), types.length))
+    }
+    static updateTSIntersectionType(original: TSIntersectionType | undefined, types: readonly Expression[]): TSIntersectionType {
+        return new TSIntersectionType(global.generatedEs2panda._UpdateTSIntersectionType(global.context, passNode(original), passNodeArray(types), types.length))
+    }
+    get types(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._TSIntersectionTypeTypesConst(global.context, this.peer))
+    }
+}
+export function isTSIntersectionType(node: object | undefined): node is TSIntersectionType {
+    return node instanceof TSIntersectionType
+}
+if (!nodeByType.has(112)) {
+    nodeByType.set(112, TSIntersectionType)
+}

package/build/libarkts-copy/src/generated/peers/TSLiteralType.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 TSLiteralType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 108)
+        super(pointer)
+    }
+    static createTSLiteralType(literal?: Expression): TSLiteralType {
+        return new TSLiteralType(global.generatedEs2panda._CreateTSLiteralType(global.context, passNode(literal)))
+    }
+    static updateTSLiteralType(original?: TSLiteralType, literal?: Expression): TSLiteralType {
+        return new TSLiteralType(global.generatedEs2panda._UpdateTSLiteralType(global.context, passNode(original), passNode(literal)))
+    }
+    get literal(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSLiteralTypeLiteralConst(global.context, this.peer))
+    }
+}
+export function isTSLiteralType(node: object | undefined): node is TSLiteralType {
+    return node instanceof TSLiteralType
+}
+if (!nodeByType.has(108)) {
+    nodeByType.set(108, TSLiteralType)
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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 { Es2pandaMappedOption } from "./../Es2pandaEnums"
+import { TSTypeParameter } from "./TSTypeParameter"
+import { TypeNode } from "./TypeNode"
+export class TSMappedType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 113)
+        super(pointer)
+    }
+    static createTSMappedType(typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType {
+        return new TSMappedType(global.generatedEs2panda._CreateTSMappedType(global.context, passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg))
+    }
+    static updateTSMappedType(original: TSMappedType | undefined, typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType {
+        return new TSMappedType(global.generatedEs2panda._UpdateTSMappedType(global.context, passNode(original), passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg))
+    }
+    get typeParameter(): TSTypeParameter | undefined {
+        return unpackNode(global.generatedEs2panda._TSMappedTypeTypeParameter(global.context, this.peer))
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSMappedTypeTypeAnnotation(global.context, this.peer))
+    }
+    get readonly(): Es2pandaMappedOption {
+        return global.generatedEs2panda._TSMappedTypeReadonly(global.context, this.peer)
+    }
+    get optional(): Es2pandaMappedOption {
+        return global.generatedEs2panda._TSMappedTypeOptional(global.context, this.peer)
+    }
+}
+export function isTSMappedType(node: object | undefined): node is TSMappedType {
+    return node instanceof TSMappedType
+}
+if (!nodeByType.has(113)) {
+    nodeByType.set(113, TSMappedType)
+}

package/build/libarkts-copy/src/generated/peers/TSMethodSignature.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 { Expression } from "./Expression"
+import { FunctionSignature } from "./FunctionSignature"
+import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
+import { TypeNode } from "./TypeNode"
+export class TSMethodSignature extends AstNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 105)
+        super(pointer)
+    }
+    static createTSMethodSignature(key: Expression | undefined, signature: FunctionSignature | undefined, computed: boolean, optional_arg: boolean): TSMethodSignature {
+        return new TSMethodSignature(global.generatedEs2panda._CreateTSMethodSignature(global.context, passNode(key), passNode(signature), computed, optional_arg))
+    }
+    static updateTSMethodSignature(original: TSMethodSignature | undefined, key: Expression | undefined, signature: FunctionSignature | undefined, computed: boolean, optional_arg: boolean): TSMethodSignature {
+        return new TSMethodSignature(global.generatedEs2panda._UpdateTSMethodSignature(global.context, passNode(original), passNode(key), passNode(signature), computed, optional_arg))
+    }
+    get key(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSMethodSignatureKeyConst(global.context, this.peer))
+    }
+    get typeParams(): TSTypeParameterDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._TSMethodSignatureTypeParamsConst(global.context, this.peer))
+    }
+    get params(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._TSMethodSignatureParamsConst(global.context, this.peer))
+    }
+    get returnTypeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSMethodSignatureReturnTypeAnnotationConst(global.context, this.peer))
+    }
+    get computed(): boolean {
+        return global.generatedEs2panda._TSMethodSignatureComputedConst(global.context, this.peer)
+    }
+    get optional(): boolean {
+        return global.generatedEs2panda._TSMethodSignatureOptionalConst(global.context, this.peer)
+    }
+}
+export function isTSMethodSignature(node: object | undefined): node is TSMethodSignature {
+    return node instanceof TSMethodSignature
+}
+if (!nodeByType.has(105)) {
+    nodeByType.set(105, TSMethodSignature)
+}

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

@@ -0,0 +1,53 @@
+/*
+ * 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 TSModuleBlock extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 114)
+        super(pointer)
+    }
+    static createTSModuleBlock(statements: readonly Statement[]): TSModuleBlock {
+        return new TSModuleBlock(global.generatedEs2panda._CreateTSModuleBlock(global.context, passNodeArray(statements), statements.length))
+    }
+    static updateTSModuleBlock(original: TSModuleBlock | undefined, statements: readonly Statement[]): TSModuleBlock {
+        return new TSModuleBlock(global.generatedEs2panda._UpdateTSModuleBlock(global.context, passNode(original), passNodeArray(statements), statements.length))
+    }
+    get statements(): readonly Statement[] {
+        return unpackNodeArray(global.generatedEs2panda._TSModuleBlockStatementsConst(global.context, this.peer))
+    }
+}
+export function isTSModuleBlock(node: object | undefined): node is TSModuleBlock {
+    return node instanceof TSModuleBlock
+}
+if (!nodeByType.has(114)) {
+    nodeByType.set(114, TSModuleBlock)
+}

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

@@ -0,0 +1,63 @@
+/*
+ * 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 TSModuleDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 122)
+        super(pointer)
+    }
+    static createTSModuleDeclaration(name: Expression | undefined, body: Statement | undefined, declare: boolean, _global: boolean): TSModuleDeclaration {
+        return new TSModuleDeclaration(global.generatedEs2panda._CreateTSModuleDeclaration(global.context, passNode(name), passNode(body), declare, _global))
+    }
+    static updateTSModuleDeclaration(original: TSModuleDeclaration | undefined, name: Expression | undefined, body: Statement | undefined, declare: boolean, _global: boolean): TSModuleDeclaration {
+        return new TSModuleDeclaration(global.generatedEs2panda._UpdateTSModuleDeclaration(global.context, passNode(original), passNode(name), passNode(body), declare, _global))
+    }
+    get name(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSModuleDeclarationNameConst(global.context, this.peer))
+    }
+    get body(): Statement | undefined {
+        return unpackNode(global.generatedEs2panda._TSModuleDeclarationBodyConst(global.context, this.peer))
+    }
+    get global(): boolean {
+        return global.generatedEs2panda._TSModuleDeclarationGlobalConst(global.context, this.peer)
+    }
+    get isExternalOrAmbient(): boolean {
+        return global.generatedEs2panda._TSModuleDeclarationIsExternalOrAmbientConst(global.context, this.peer)
+    }
+}
+export function isTSModuleDeclaration(node: object | undefined): node is TSModuleDeclaration {
+    return node instanceof TSModuleDeclaration
+}
+if (!nodeByType.has(122)) {
+    nodeByType.set(122, TSModuleDeclaration)
+}

package/build/libarkts-copy/src/generated/peers/TSNamedTupleMember.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 TSNamedTupleMember extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 134)
+        super(pointer)
+    }
+    static createTSNamedTupleMember(label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember {
+        return new TSNamedTupleMember(global.generatedEs2panda._CreateTSNamedTupleMember(global.context, passNode(label), passNode(elementType), optional_arg))
+    }
+    static updateTSNamedTupleMember(original: TSNamedTupleMember | undefined, label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember {
+        return new TSNamedTupleMember(global.generatedEs2panda._UpdateTSNamedTupleMember(global.context, passNode(original), passNode(label), passNode(elementType), optional_arg))
+    }
+    get label(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSNamedTupleMemberLabelConst(global.context, this.peer))
+    }
+    get elementType(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSNamedTupleMemberElementTypeConst(global.context, this.peer))
+    }
+    get isOptional(): boolean {
+        return global.generatedEs2panda._TSNamedTupleMemberIsOptionalConst(global.context, this.peer)
+    }
+}
+export function isTSNamedTupleMember(node: object | undefined): node is TSNamedTupleMember {
+    return node instanceof TSNamedTupleMember
+}
+if (!nodeByType.has(134)) {
+    nodeByType.set(134, TSNamedTupleMember)
+}