@idlizer/arktscgen 2.1.2

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

@@ -0,0 +1,65 @@
+/*
+ * 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 TSConstructorType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 125)
+        super(pointer)
+    }
+    static createTSConstructorType(signature: FunctionSignature | undefined, abstract: boolean): TSConstructorType {
+        return new TSConstructorType(global.generatedEs2panda._CreateTSConstructorType(global.context, passNode(signature), abstract))
+    }
+    static updateTSConstructorType(original: TSConstructorType | undefined, signature: FunctionSignature | undefined, abstract: boolean): TSConstructorType {
+        return new TSConstructorType(global.generatedEs2panda._UpdateTSConstructorType(global.context, passNode(original), passNode(signature), abstract))
+    }
+    get typeParams(): TSTypeParameterDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._TSConstructorTypeTypeParamsConst(global.context, this.peer))
+    }
+    get params(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._TSConstructorTypeParamsConst(global.context, this.peer))
+    }
+    get returnType(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSConstructorTypeReturnTypeConst(global.context, this.peer))
+    }
+    get abstract(): boolean {
+        return global.generatedEs2panda._TSConstructorTypeAbstractConst(global.context, this.peer)
+    }
+}
+export function isTSConstructorType(node: object | undefined): node is TSConstructorType {
+    return node instanceof TSConstructorType
+}
+if (!nodeByType.has(125)) {
+    nodeByType.set(125, TSConstructorType)
+}

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

@@ -0,0 +1,81 @@
+/*
+ * 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 { ClassDefinition } from "./ClassDefinition"
+import { Decorator } from "./Decorator"
+import { Identifier } from "./Identifier"
+import { TypedStatement } from "./TypedStatement"
+export class TSEnumDeclaration extends TypedStatement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 86)
+        super(pointer)
+    }
+    static createTSEnumDeclaration(key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration {
+        return new TSEnumDeclaration(global.generatedEs2panda._CreateTSEnumDeclaration(global.context, passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare))
+    }
+    static updateTSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration {
+        return new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration(global.context, passNode(original), passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare))
+    }
+    get key(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._TSEnumDeclarationKeyConst(global.context, this.peer))
+    }
+    get members(): readonly AstNode[] {
+        return unpackNodeArray(global.generatedEs2panda._TSEnumDeclarationMembersConst(global.context, this.peer))
+    }
+    get internalName(): string {
+        return unpackString(global.generatedEs2panda._TSEnumDeclarationInternalNameConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setInternalName(internalName: string): this {
+        global.generatedEs2panda._TSEnumDeclarationSetInternalName(global.context, this.peer, internalName)
+        return this
+    }
+    get boxedClass(): ClassDefinition | undefined {
+        return unpackNode(global.generatedEs2panda._TSEnumDeclarationBoxedClassConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setBoxedClass(wrapperClass?: ClassDefinition): this {
+        global.generatedEs2panda._TSEnumDeclarationSetBoxedClass(global.context, this.peer, passNode(wrapperClass))
+        return this
+    }
+    get isConst(): boolean {
+        return global.generatedEs2panda._TSEnumDeclarationIsConstConst(global.context, this.peer)
+    }
+    get decorators(): readonly Decorator[] {
+        return unpackNodeArray(global.generatedEs2panda._TSEnumDeclarationDecoratorsConst(global.context, this.peer))
+    }
+}
+export function isTSEnumDeclaration(node: object | undefined): node is TSEnumDeclaration {
+    return node instanceof TSEnumDeclaration
+}
+if (!nodeByType.has(86)) {
+    nodeByType.set(86, TSEnumDeclaration)
+}

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

@@ -0,0 +1,66 @@
+/*
+ * 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 TSEnumMember extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 87)
+        super(pointer)
+    }
+    static create1TSEnumMember(key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember {
+        return new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember1(global.context, passNode(key), passNode(init), isGenerated))
+    }
+    static updateTSEnumMember(original?: TSEnumMember, key?: Expression, init?: Expression): TSEnumMember {
+        return new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember(global.context, passNode(original), passNode(key), passNode(init)))
+    }
+    static update1TSEnumMember(original: TSEnumMember | undefined, key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember {
+        return new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember1(global.context, passNode(original), passNode(key), passNode(init), isGenerated))
+    }
+    get key(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSEnumMemberKeyConst(global.context, this.peer))
+    }
+    get init(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSEnumMemberInitConst(global.context, this.peer))
+    }
+    get isGenerated(): boolean {
+        return global.generatedEs2panda._TSEnumMemberIsGeneratedConst(global.context, this.peer)
+    }
+    get name(): string {
+        return unpackString(global.generatedEs2panda._TSEnumMemberNameConst(global.context, this.peer))
+    }
+}
+export function isTSEnumMember(node: object | undefined): node is TSEnumMember {
+    return node instanceof TSEnumMember
+}
+if (!nodeByType.has(87)) {
+    nodeByType.set(87, TSEnumMember)
+}

package/build/libarkts-copy/src/generated/peers/TSExternalModuleReference.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 TSExternalModuleReference extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 88)
+        super(pointer)
+    }
+    static createTSExternalModuleReference(expr?: Expression): TSExternalModuleReference {
+        return new TSExternalModuleReference(global.generatedEs2panda._CreateTSExternalModuleReference(global.context, passNode(expr)))
+    }
+    static updateTSExternalModuleReference(original?: TSExternalModuleReference, expr?: Expression): TSExternalModuleReference {
+        return new TSExternalModuleReference(global.generatedEs2panda._UpdateTSExternalModuleReference(global.context, passNode(original), passNode(expr)))
+    }
+    get expr(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSExternalModuleReferenceExprConst(global.context, this.peer))
+    }
+}
+export function isTSExternalModuleReference(node: object | undefined): node is TSExternalModuleReference {
+    return node instanceof TSExternalModuleReference
+}
+if (!nodeByType.has(88)) {
+    nodeByType.set(88, TSExternalModuleReference)
+}

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

@@ -0,0 +1,67 @@
+/*
+ * 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 TSFunctionType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 124)
+        super(pointer)
+    }
+    static createTSFunctionType(signature?: FunctionSignature): TSFunctionType {
+        return new TSFunctionType(global.generatedEs2panda._CreateTSFunctionType(global.context, passNode(signature)))
+    }
+    static updateTSFunctionType(original?: TSFunctionType, signature?: FunctionSignature): TSFunctionType {
+        return new TSFunctionType(global.generatedEs2panda._UpdateTSFunctionType(global.context, passNode(original), passNode(signature)))
+    }
+    get typeParams(): TSTypeParameterDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._TSFunctionTypeTypeParamsConst(global.context, this.peer))
+    }
+    get params(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._TSFunctionTypeParamsConst(global.context, this.peer))
+    }
+    get returnType(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSFunctionTypeReturnTypeConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setNullable(nullable: boolean): this {
+        global.generatedEs2panda._TSFunctionTypeSetNullable(global.context, this.peer, nullable)
+        return this
+    }
+}
+export function isTSFunctionType(node: object | undefined): node is TSFunctionType {
+    return node instanceof TSFunctionType
+}
+if (!nodeByType.has(124)) {
+    nodeByType.set(124, TSFunctionType)
+}

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

@@ -0,0 +1,61 @@
+/*
+ * 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 { Identifier } from "./Identifier"
+import { Statement } from "./Statement"
+export class TSImportEqualsDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 123)
+        super(pointer)
+    }
+    static createTSImportEqualsDeclaration(id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration {
+        return new TSImportEqualsDeclaration(global.generatedEs2panda._CreateTSImportEqualsDeclaration(global.context, passNode(id), passNode(moduleReference), isExport))
+    }
+    static updateTSImportEqualsDeclaration(original: TSImportEqualsDeclaration | undefined, id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration {
+        return new TSImportEqualsDeclaration(global.generatedEs2panda._UpdateTSImportEqualsDeclaration(global.context, passNode(original), passNode(id), passNode(moduleReference), isExport))
+    }
+    get id(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._TSImportEqualsDeclarationIdConst(global.context, this.peer))
+    }
+    get moduleReference(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSImportEqualsDeclarationModuleReferenceConst(global.context, this.peer))
+    }
+    get isExport(): boolean {
+        return global.generatedEs2panda._TSImportEqualsDeclarationIsExportConst(global.context, this.peer)
+    }
+}
+export function isTSImportEqualsDeclaration(node: object | undefined): node is TSImportEqualsDeclaration {
+    return node instanceof TSImportEqualsDeclaration
+}
+if (!nodeByType.has(123)) {
+    nodeByType.set(123, TSImportEqualsDeclaration)
+}

package/build/libarkts-copy/src/generated/peers/TSImportType.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 { Expression } from "./Expression"
+import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
+import { TypeNode } from "./TypeNode"
+export class TSImportType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 111)
+        super(pointer)
+    }
+    static createTSImportType(param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType {
+        return new TSImportType(global.generatedEs2panda._CreateTSImportType(global.context, passNode(param), passNode(typeParams), passNode(qualifier), isTypeof))
+    }
+    static updateTSImportType(original: TSImportType | undefined, param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType {
+        return new TSImportType(global.generatedEs2panda._UpdateTSImportType(global.context, passNode(original), passNode(param), passNode(typeParams), passNode(qualifier), isTypeof))
+    }
+    get param(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSImportTypeParamConst(global.context, this.peer))
+    }
+    get typeParams(): TSTypeParameterInstantiation | undefined {
+        return unpackNode(global.generatedEs2panda._TSImportTypeTypeParamsConst(global.context, this.peer))
+    }
+    get qualifier(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSImportTypeQualifierConst(global.context, this.peer))
+    }
+    get isTypeof(): boolean {
+        return global.generatedEs2panda._TSImportTypeIsTypeofConst(global.context, this.peer)
+    }
+}
+export function isTSImportType(node: object | undefined): node is TSImportType {
+    return node instanceof TSImportType
+}
+if (!nodeByType.has(111)) {
+    nodeByType.set(111, TSImportType)
+}

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

@@ -0,0 +1,65 @@
+/*
+ * 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 { Es2pandaTSIndexSignatureKind } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { TypeNode } from "./TypeNode"
+import { TypedAstNode } from "./TypedAstNode"
+export class TSIndexSignature extends TypedAstNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 135)
+        super(pointer)
+    }
+    static createTSIndexSignature(param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature {
+        return new TSIndexSignature(global.generatedEs2panda._CreateTSIndexSignature(global.context, passNode(param), passNode(typeAnnotation), readonly_arg))
+    }
+    static updateTSIndexSignature(original: TSIndexSignature | undefined, param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature {
+        return new TSIndexSignature(global.generatedEs2panda._UpdateTSIndexSignature(global.context, passNode(original), passNode(param), passNode(typeAnnotation), readonly_arg))
+    }
+    get param(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSIndexSignatureParamConst(global.context, this.peer))
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSIndexSignatureTypeAnnotationConst(global.context, this.peer))
+    }
+    get readonly(): boolean {
+        return global.generatedEs2panda._TSIndexSignatureReadonlyConst(global.context, this.peer)
+    }
+    get kind(): Es2pandaTSIndexSignatureKind {
+        return global.generatedEs2panda._TSIndexSignatureKindConst(global.context, this.peer)
+    }
+}
+export function isTSIndexSignature(node: object | undefined): node is TSIndexSignature {
+    return node instanceof TSIndexSignature
+}
+if (!nodeByType.has(135)) {
+    nodeByType.set(135, TSIndexSignature)
+}

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

@@ -0,0 +1,56 @@
+/*
+ * 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 TSIndexedAccessType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 129)
+        super(pointer)
+    }
+    static createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType {
+        return new TSIndexedAccessType(global.generatedEs2panda._CreateTSIndexedAccessType(global.context, passNode(objectType), passNode(indexType)))
+    }
+    static updateTSIndexedAccessType(original?: TSIndexedAccessType, objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType {
+        return new TSIndexedAccessType(global.generatedEs2panda._UpdateTSIndexedAccessType(global.context, passNode(original), passNode(objectType), passNode(indexType)))
+    }
+    get objectType(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSIndexedAccessTypeObjectTypeConst(global.context, this.peer))
+    }
+    get indexType(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSIndexedAccessTypeIndexTypeConst(global.context, this.peer))
+    }
+}
+export function isTSIndexedAccessType(node: object | undefined): node is TSIndexedAccessType {
+    return node instanceof TSIndexedAccessType
+}
+if (!nodeByType.has(129)) {
+    nodeByType.set(129, TSIndexedAccessType)
+}

package/build/libarkts-copy/src/generated/peers/TSInferType.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 { TSTypeParameter } from "./TSTypeParameter"
+import { TypeNode } from "./TypeNode"
+export class TSInferType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 109)
+        super(pointer)
+    }
+    static createTSInferType(typeParam?: TSTypeParameter): TSInferType {
+        return new TSInferType(global.generatedEs2panda._CreateTSInferType(global.context, passNode(typeParam)))
+    }
+    static updateTSInferType(original?: TSInferType, typeParam?: TSTypeParameter): TSInferType {
+        return new TSInferType(global.generatedEs2panda._UpdateTSInferType(global.context, passNode(original), passNode(typeParam)))
+    }
+    get typeParam(): TSTypeParameter | undefined {
+        return unpackNode(global.generatedEs2panda._TSInferTypeTypeParamConst(global.context, this.peer))
+    }
+}
+export function isTSInferType(node: object | undefined): node is TSInferType {
+    return node instanceof TSInferType
+}
+if (!nodeByType.has(109)) {
+    nodeByType.set(109, TSInferType)
+}