@idlizer/arktscgen 2.1.2

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

package/build/libarkts-copy/src/generated/peers/TSTupleType.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 { TypeNode } from "./TypeNode"
+export class TSTupleType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 133)
+        super(pointer)
+    }
+    static createTSTupleType(elementTypes: readonly TypeNode[]): TSTupleType {
+        return new TSTupleType(global.generatedEs2panda._CreateTSTupleType(global.context, passNodeArray(elementTypes), elementTypes.length))
+    }
+    static updateTSTupleType(original: TSTupleType | undefined, elementTypes: readonly TypeNode[]): TSTupleType {
+        return new TSTupleType(global.generatedEs2panda._UpdateTSTupleType(global.context, passNode(original), passNodeArray(elementTypes), elementTypes.length))
+    }
+    get elementType(): readonly TypeNode[] {
+        return unpackNodeArray(global.generatedEs2panda._TSTupleTypeElementTypeConst(global.context, this.peer))
+    }
+}
+export function isTSTupleType(node: object | undefined): node is TSTupleType {
+    return node instanceof TSTupleType
+}
+if (!nodeByType.has(133)) {
+    nodeByType.set(133, TSTupleType)
+}

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

@@ -0,0 +1,88 @@
+/*
+ * 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 { AnnotatedStatement } from "./AnnotatedStatement"
+import { AnnotationUsage } from "./AnnotationUsage"
+import { Decorator } from "./Decorator"
+import { Identifier } from "./Identifier"
+import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
+import { TypeNode } from "./TypeNode"
+export class TSTypeAliasDeclaration extends AnnotatedStatement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 126)
+        super(pointer)
+    }
+    static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration {
+        return new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration(global.context, passNode(id), passNode(typeParams), passNode(typeAnnotation)))
+    }
+    static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration {
+        return new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration(global.context, passNode(original), passNode(id), passNode(typeParams), passNode(typeAnnotation)))
+    }
+    static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier): TSTypeAliasDeclaration {
+        return new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration1(global.context, passNode(original), passNode(id)))
+    }
+    get id(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationIdConst(global.context, this.peer))
+    }
+    get typeParams(): TSTypeParameterDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeParamsConst(global.context, this.peer))
+    }
+    get decorators(): readonly Decorator[] {
+        return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationDecoratorsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTypeParameters(typeParams?: TSTypeParameterDeclaration): this {
+        global.generatedEs2panda._TSTypeAliasDeclarationSetTypeParameters(global.context, this.peer, passNode(typeParams))
+        return this
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._TSTypeAliasDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTsTypeAnnotation(typeAnnotation?: TypeNode): this {
+        global.generatedEs2panda._TSTypeAliasDeclarationSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
+        return this
+    }
+}
+export function isTSTypeAliasDeclaration(node: object | undefined): node is TSTypeAliasDeclaration {
+    return node instanceof TSTypeAliasDeclaration
+}
+if (!nodeByType.has(126)) {
+    nodeByType.set(126, TSTypeAliasDeclaration)
+}

package/build/libarkts-copy/src/generated/peers/TSTypeAssertion.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 { AnnotatedExpression } from "./AnnotatedExpression"
+import { Expression } from "./Expression"
+import { TypeNode } from "./TypeNode"
+export class TSTypeAssertion extends AnnotatedExpression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 139)
+        super(pointer)
+    }
+    static createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion {
+        return new TSTypeAssertion(global.generatedEs2panda._CreateTSTypeAssertion(global.context, passNode(typeAnnotation), passNode(expression)))
+    }
+    static updateTSTypeAssertion(original?: TSTypeAssertion, typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion {
+        return new TSTypeAssertion(global.generatedEs2panda._UpdateTSTypeAssertion(global.context, passNode(original), passNode(typeAnnotation), passNode(expression)))
+    }
+    get expression(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeAssertionGetExpressionConst(global.context, this.peer))
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeAssertionTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTsTypeAnnotation(typeAnnotation?: TypeNode): this {
+        global.generatedEs2panda._TSTypeAssertionSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
+        return this
+    }
+}
+export function isTSTypeAssertion(node: object | undefined): node is TSTypeAssertion {
+    return node instanceof TSTypeAssertion
+}
+if (!nodeByType.has(139)) {
+    nodeByType.set(139, TSTypeAssertion)
+}

package/build/libarkts-copy/src/generated/peers/TSTypeLiteral.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 { TypeNode } from "./TypeNode"
+export class TSTypeLiteral extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 103)
+        super(pointer)
+    }
+    static createTSTypeLiteral(members: readonly AstNode[]): TSTypeLiteral {
+        return new TSTypeLiteral(global.generatedEs2panda._CreateTSTypeLiteral(global.context, passNodeArray(members), members.length))
+    }
+    static updateTSTypeLiteral(original: TSTypeLiteral | undefined, members: readonly AstNode[]): TSTypeLiteral {
+        return new TSTypeLiteral(global.generatedEs2panda._UpdateTSTypeLiteral(global.context, passNode(original), passNodeArray(members), members.length))
+    }
+    get members(): readonly AstNode[] {
+        return unpackNodeArray(global.generatedEs2panda._TSTypeLiteralMembersConst(global.context, this.peer))
+    }
+}
+export function isTSTypeLiteral(node: object | undefined): node is TSTypeLiteral {
+    return node instanceof TSTypeLiteral
+}
+if (!nodeByType.has(103)) {
+    nodeByType.set(103, TSTypeLiteral)
+}

package/build/libarkts-copy/src/generated/peers/TSTypeOperator.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 { Es2pandaTSOperatorType } from "./../Es2pandaEnums"
+import { TypeNode } from "./TypeNode"
+export class TSTypeOperator extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 116)
+        super(pointer)
+    }
+    static createTSTypeOperator(type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator {
+        return new TSTypeOperator(global.generatedEs2panda._CreateTSTypeOperator(global.context, passNode(type), operatorType))
+    }
+    static updateTSTypeOperator(original: TSTypeOperator | undefined, type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator {
+        return new TSTypeOperator(global.generatedEs2panda._UpdateTSTypeOperator(global.context, passNode(original), passNode(type), operatorType))
+    }
+    get type(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeOperatorTypeConst(global.context, this.peer))
+    }
+    get isReadonly(): boolean {
+        return global.generatedEs2panda._TSTypeOperatorIsReadonlyConst(global.context, this.peer)
+    }
+    get isKeyof(): boolean {
+        return global.generatedEs2panda._TSTypeOperatorIsKeyofConst(global.context, this.peer)
+    }
+    get isUnique(): boolean {
+        return global.generatedEs2panda._TSTypeOperatorIsUniqueConst(global.context, this.peer)
+    }
+}
+export function isTSTypeOperator(node: object | undefined): node is TSTypeOperator {
+    return node instanceof TSTypeOperator
+}
+if (!nodeByType.has(116)) {
+    nodeByType.set(116, TSTypeOperator)
+}

package/build/libarkts-copy/src/generated/peers/TSTypeParameter.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 { AnnotationUsage } from "./AnnotationUsage"
+import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { Identifier } from "./Identifier"
+import { TypeNode } from "./TypeNode"
+export class TSTypeParameter extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 117)
+        super(pointer)
+    }
+    static create1TSTypeParameter(name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter {
+        return new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter1(global.context, passNode(name), passNode(constraint), passNode(defaultType), flags))
+    }
+    static updateTSTypeParameter(original?: TSTypeParameter, name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter {
+        return new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType)))
+    }
+    static update1TSTypeParameter(original: TSTypeParameter | undefined, name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter {
+        return new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter1(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType), flags))
+    }
+    get name(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeParameterNameConst(global.context, this.peer))
+    }
+    get constraint(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeParameterConstraintConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setConstraint(constraint?: TypeNode): this {
+        global.generatedEs2panda._TSTypeParameterSetConstraint(global.context, this.peer, passNode(constraint))
+        return this
+    }
+    get defaultType(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeParameterDefaultTypeConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setDefaultType(defaultType?: TypeNode): this {
+        global.generatedEs2panda._TSTypeParameterSetDefaultType(global.context, this.peer, passNode(defaultType))
+        return this
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._TSTypeParameterAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._TSTypeParameterSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isTSTypeParameter(node: object | undefined): node is TSTypeParameter {
+    return node instanceof TSTypeParameter
+}
+if (!nodeByType.has(117)) {
+    nodeByType.set(117, TSTypeParameter)
+}

package/build/libarkts-copy/src/generated/peers/TSTypeParameterDeclaration.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 { TSTypeParameter } from "./TSTypeParameter"
+export class TSTypeParameterDeclaration extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 118)
+        super(pointer)
+    }
+    static createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], requiredParams: number): TSTypeParameterDeclaration {
+        return new TSTypeParameterDeclaration(global.generatedEs2panda._CreateTSTypeParameterDeclaration(global.context, passNodeArray(params), params.length, requiredParams))
+    }
+    static updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration | undefined, params: readonly TSTypeParameter[], requiredParams: number): TSTypeParameterDeclaration {
+        return new TSTypeParameterDeclaration(global.generatedEs2panda._UpdateTSTypeParameterDeclaration(global.context, passNode(original), passNodeArray(params), params.length, requiredParams))
+    }
+    get params(): readonly TSTypeParameter[] {
+        return unpackNodeArray(global.generatedEs2panda._TSTypeParameterDeclarationParamsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    addParam(param?: TSTypeParameter): this {
+        global.generatedEs2panda._TSTypeParameterDeclarationAddParam(global.context, this.peer, passNode(param))
+        return this
+    }
+    get requiredParams(): number {
+        return global.generatedEs2panda._TSTypeParameterDeclarationRequiredParamsConst(global.context, this.peer)
+    }
+}
+export function isTSTypeParameterDeclaration(node: object | undefined): node is TSTypeParameterDeclaration {
+    return node instanceof TSTypeParameterDeclaration
+}
+if (!nodeByType.has(118)) {
+    nodeByType.set(118, TSTypeParameterDeclaration)
+}

package/build/libarkts-copy/src/generated/peers/TSTypeParameterInstantiation.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 TSTypeParameterInstantiation extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 119)
+        super(pointer)
+    }
+    static createTSTypeParameterInstantiation(params: readonly TypeNode[]): TSTypeParameterInstantiation {
+        return new TSTypeParameterInstantiation(global.generatedEs2panda._CreateTSTypeParameterInstantiation(global.context, passNodeArray(params), params.length))
+    }
+    static updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation | undefined, params: readonly TypeNode[]): TSTypeParameterInstantiation {
+        return new TSTypeParameterInstantiation(global.generatedEs2panda._UpdateTSTypeParameterInstantiation(global.context, passNode(original), passNodeArray(params), params.length))
+    }
+    get params(): readonly TypeNode[] {
+        return unpackNodeArray(global.generatedEs2panda._TSTypeParameterInstantiationParamsConst(global.context, this.peer))
+    }
+}
+export function isTSTypeParameterInstantiation(node: object | undefined): node is TSTypeParameterInstantiation {
+    return node instanceof TSTypeParameterInstantiation
+}
+if (!nodeByType.has(119)) {
+    nodeByType.set(119, TSTypeParameterInstantiation)
+}

package/build/libarkts-copy/src/generated/peers/TSTypePredicate.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 TSTypePredicate extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 120)
+        super(pointer)
+    }
+    static createTSTypePredicate(parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate {
+        return new TSTypePredicate(global.generatedEs2panda._CreateTSTypePredicate(global.context, passNode(parameterName), passNode(typeAnnotation), asserts))
+    }
+    static updateTSTypePredicate(original: TSTypePredicate | undefined, parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate {
+        return new TSTypePredicate(global.generatedEs2panda._UpdateTSTypePredicate(global.context, passNode(original), passNode(parameterName), passNode(typeAnnotation), asserts))
+    }
+    get parameterName(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypePredicateParameterNameConst(global.context, this.peer))
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypePredicateTypeAnnotationConst(global.context, this.peer))
+    }
+    get asserts(): boolean {
+        return global.generatedEs2panda._TSTypePredicateAssertsConst(global.context, this.peer)
+    }
+}
+export function isTSTypePredicate(node: object | undefined): node is TSTypePredicate {
+    return node instanceof TSTypePredicate
+}
+if (!nodeByType.has(120)) {
+    nodeByType.set(120, TSTypePredicate)
+}