@idlizer/arktscgen 2.1.2

package/build/libarkts-copy/src/generated/peers/TSNeverKeyword.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 TSNeverKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 98)
+        super(pointer)
+    }
+    static createTSNeverKeyword(): TSNeverKeyword {
+        return new TSNeverKeyword(global.generatedEs2panda._CreateTSNeverKeyword(global.context))
+    }
+    static updateTSNeverKeyword(original?: TSNeverKeyword): TSNeverKeyword {
+        return new TSNeverKeyword(global.generatedEs2panda._UpdateTSNeverKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSNeverKeyword(node: object | undefined): node is TSNeverKeyword {
+    return node instanceof TSNeverKeyword
+}
+if (!nodeByType.has(98)) {
+    nodeByType.set(98, TSNeverKeyword)
+}

package/build/libarkts-copy/src/generated/peers/TSNonNullExpression.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"
+export class TSNonNullExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 99)
+        super(pointer)
+    }
+    static createTSNonNullExpression(expr?: Expression): TSNonNullExpression {
+        return new TSNonNullExpression(global.generatedEs2panda._CreateTSNonNullExpression(global.context, passNode(expr)))
+    }
+    static updateTSNonNullExpression(original?: TSNonNullExpression, expr?: Expression): TSNonNullExpression {
+        return new TSNonNullExpression(global.generatedEs2panda._UpdateTSNonNullExpression(global.context, passNode(original), passNode(expr)))
+    }
+    get expr(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSNonNullExpressionExprConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setExpr(expr?: Expression): this {
+        global.generatedEs2panda._TSNonNullExpressionSetExpr(global.context, this.peer, passNode(expr))
+        return this
+    }
+}
+export function isTSNonNullExpression(node: object | undefined): node is TSNonNullExpression {
+    return node instanceof TSNonNullExpression
+}
+if (!nodeByType.has(99)) {
+    nodeByType.set(99, TSNonNullExpression)
+}

package/build/libarkts-copy/src/generated/peers/TSNullKeyword.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 TSNullKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 100)
+        super(pointer)
+    }
+    static createTSNullKeyword(): TSNullKeyword {
+        return new TSNullKeyword(global.generatedEs2panda._CreateTSNullKeyword(global.context))
+    }
+    static updateTSNullKeyword(original?: TSNullKeyword): TSNullKeyword {
+        return new TSNullKeyword(global.generatedEs2panda._UpdateTSNullKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSNullKeyword(node: object | undefined): node is TSNullKeyword {
+    return node instanceof TSNullKeyword
+}
+if (!nodeByType.has(100)) {
+    nodeByType.set(100, TSNullKeyword)
+}

package/build/libarkts-copy/src/generated/peers/TSNumberKeyword.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 TSNumberKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 89)
+        super(pointer)
+    }
+    static createTSNumberKeyword(): TSNumberKeyword {
+        return new TSNumberKeyword(global.generatedEs2panda._CreateTSNumberKeyword(global.context))
+    }
+    static updateTSNumberKeyword(original?: TSNumberKeyword): TSNumberKeyword {
+        return new TSNumberKeyword(global.generatedEs2panda._UpdateTSNumberKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSNumberKeyword(node: object | undefined): node is TSNumberKeyword {
+    return node instanceof TSNumberKeyword
+}
+if (!nodeByType.has(89)) {
+    nodeByType.set(89, TSNumberKeyword)
+}

package/build/libarkts-copy/src/generated/peers/TSObjectKeyword.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 TSObjectKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 96)
+        super(pointer)
+    }
+    static createTSObjectKeyword(): TSObjectKeyword {
+        return new TSObjectKeyword(global.generatedEs2panda._CreateTSObjectKeyword(global.context))
+    }
+    static updateTSObjectKeyword(original?: TSObjectKeyword): TSObjectKeyword {
+        return new TSObjectKeyword(global.generatedEs2panda._UpdateTSObjectKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSObjectKeyword(node: object | undefined): node is TSObjectKeyword {
+    return node instanceof TSObjectKeyword
+}
+if (!nodeByType.has(96)) {
+    nodeByType.set(96, TSObjectKeyword)
+}

package/build/libarkts-copy/src/generated/peers/TSParameterProperty.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 { Es2pandaAccessibilityOption } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+export class TSParameterProperty extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 121)
+        super(pointer)
+    }
+    static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty {
+        return new TSParameterProperty(global.generatedEs2panda._CreateTSParameterProperty(global.context, accessibility, passNode(parameter), readonly_arg, isStatic, isExport))
+    }
+    static updateTSParameterProperty(original: TSParameterProperty | undefined, accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty {
+        return new TSParameterProperty(global.generatedEs2panda._UpdateTSParameterProperty(global.context, passNode(original), accessibility, passNode(parameter), readonly_arg, isStatic, isExport))
+    }
+    get accessibility(): Es2pandaAccessibilityOption {
+        return global.generatedEs2panda._TSParameterPropertyAccessibilityConst(global.context, this.peer)
+    }
+    get readonly(): boolean {
+        return global.generatedEs2panda._TSParameterPropertyReadonlyConst(global.context, this.peer)
+    }
+    get isStatic(): boolean {
+        return global.generatedEs2panda._TSParameterPropertyIsStaticConst(global.context, this.peer)
+    }
+    get isExport(): boolean {
+        return global.generatedEs2panda._TSParameterPropertyIsExportConst(global.context, this.peer)
+    }
+    get parameter(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSParameterPropertyParameterConst(global.context, this.peer))
+    }
+}
+export function isTSParameterProperty(node: object | undefined): node is TSParameterProperty {
+    return node instanceof TSParameterProperty
+}
+if (!nodeByType.has(121)) {
+    nodeByType.set(121, TSParameterProperty)
+}

package/build/libarkts-copy/src/generated/peers/TSParenthesizedType.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 TSParenthesizedType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 107)
+        super(pointer)
+    }
+    static createTSParenthesizedType(type?: TypeNode): TSParenthesizedType {
+        return new TSParenthesizedType(global.generatedEs2panda._CreateTSParenthesizedType(global.context, passNode(type)))
+    }
+    static updateTSParenthesizedType(original?: TSParenthesizedType, type?: TypeNode): TSParenthesizedType {
+        return new TSParenthesizedType(global.generatedEs2panda._UpdateTSParenthesizedType(global.context, passNode(original), passNode(type)))
+    }
+    get type(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSParenthesizedTypeTypeConst(global.context, this.peer))
+    }
+}
+export function isTSParenthesizedType(node: object | undefined): node is TSParenthesizedType {
+    return node instanceof TSParenthesizedType
+}
+if (!nodeByType.has(107)) {
+    nodeByType.set(107, TSParenthesizedType)
+}

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

@@ -0,0 +1,72 @@
+/*
+ * 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 { AnnotatedAstNode } from "./AnnotatedAstNode"
+import { Expression } from "./Expression"
+import { TypeNode } from "./TypeNode"
+export class TSPropertySignature extends AnnotatedAstNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 104)
+        super(pointer)
+    }
+    static createTSPropertySignature(key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature {
+        return new TSPropertySignature(global.generatedEs2panda._CreateTSPropertySignature(global.context, passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg))
+    }
+    static updateTSPropertySignature(original: TSPropertySignature | undefined, key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature {
+        return new TSPropertySignature(global.generatedEs2panda._UpdateTSPropertySignature(global.context, passNode(original), passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg))
+    }
+    get key(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSPropertySignatureKeyConst(global.context, this.peer))
+    }
+    get computed(): boolean {
+        return global.generatedEs2panda._TSPropertySignatureComputedConst(global.context, this.peer)
+    }
+    get optional(): boolean {
+        return global.generatedEs2panda._TSPropertySignatureOptionalConst(global.context, this.peer)
+    }
+    get readonly(): boolean {
+        return global.generatedEs2panda._TSPropertySignatureReadonlyConst(global.context, this.peer)
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSPropertySignatureTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTsTypeAnnotation(typeAnnotation?: TypeNode): this {
+        global.generatedEs2panda._TSPropertySignatureSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
+        return this
+    }
+}
+export function isTSPropertySignature(node: object | undefined): node is TSPropertySignature {
+    return node instanceof TSPropertySignature
+}
+if (!nodeByType.has(104)) {
+    nodeByType.set(104, TSPropertySignature)
+}

package/build/libarkts-copy/src/generated/peers/TSQualifiedName.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 { Identifier } from "./Identifier"
+export class TSQualifiedName extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 128)
+        super(pointer)
+    }
+    static createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName {
+        return new TSQualifiedName(global.generatedEs2panda._CreateTSQualifiedName(global.context, passNode(left), passNode(right)))
+    }
+    static updateTSQualifiedName(original?: TSQualifiedName, left?: Expression, right?: Identifier): TSQualifiedName {
+        return new TSQualifiedName(global.generatedEs2panda._UpdateTSQualifiedName(global.context, passNode(original), passNode(left), passNode(right)))
+    }
+    get left(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSQualifiedNameLeftConst(global.context, this.peer))
+    }
+    get right(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._TSQualifiedNameRightConst(global.context, this.peer))
+    }
+    get name(): string {
+        return unpackString(global.generatedEs2panda._TSQualifiedNameNameConst(global.context, this.peer))
+    }
+    get resolveLeftMostQualifiedName(): TSQualifiedName | undefined {
+        return unpackNode(global.generatedEs2panda._TSQualifiedNameResolveLeftMostQualifiedNameConst(global.context, this.peer))
+    }
+}
+export function isTSQualifiedName(node: object | undefined): node is TSQualifiedName {
+    return node instanceof TSQualifiedName
+}
+if (!nodeByType.has(128)) {
+    nodeByType.set(128, TSQualifiedName)
+}

package/build/libarkts-copy/src/generated/peers/TSSignatureDeclaration.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 { Es2pandaTSSignatureDeclarationKind } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { FunctionSignature } from "./FunctionSignature"
+import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
+import { TypeNode } from "./TypeNode"
+import { TypedAstNode } from "./TypedAstNode"
+export class TSSignatureDeclaration extends TypedAstNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 106)
+        super(pointer)
+    }
+    static createTSSignatureDeclaration(kind: Es2pandaTSSignatureDeclarationKind, signature?: FunctionSignature): TSSignatureDeclaration {
+        return new TSSignatureDeclaration(global.generatedEs2panda._CreateTSSignatureDeclaration(global.context, kind, passNode(signature)))
+    }
+    static updateTSSignatureDeclaration(original: TSSignatureDeclaration | undefined, kind: Es2pandaTSSignatureDeclarationKind, signature?: FunctionSignature): TSSignatureDeclaration {
+        return new TSSignatureDeclaration(global.generatedEs2panda._UpdateTSSignatureDeclaration(global.context, passNode(original), kind, passNode(signature)))
+    }
+    get typeParams(): TSTypeParameterDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._TSSignatureDeclarationTypeParamsConst(global.context, this.peer))
+    }
+    get params(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._TSSignatureDeclarationParamsConst(global.context, this.peer))
+    }
+    get returnTypeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSSignatureDeclarationReturnTypeAnnotationConst(global.context, this.peer))
+    }
+    get kind(): Es2pandaTSSignatureDeclarationKind {
+        return global.generatedEs2panda._TSSignatureDeclarationKindConst(global.context, this.peer)
+    }
+}
+export function isTSSignatureDeclaration(node: object | undefined): node is TSSignatureDeclaration {
+    return node instanceof TSSignatureDeclaration
+}
+if (!nodeByType.has(106)) {
+    nodeByType.set(106, TSSignatureDeclaration)
+}

package/build/libarkts-copy/src/generated/peers/TSStringKeyword.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 TSStringKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 91)
+        super(pointer)
+    }
+    static createTSStringKeyword(): TSStringKeyword {
+        return new TSStringKeyword(global.generatedEs2panda._CreateTSStringKeyword(global.context))
+    }
+    static updateTSStringKeyword(original?: TSStringKeyword): TSStringKeyword {
+        return new TSStringKeyword(global.generatedEs2panda._UpdateTSStringKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSStringKeyword(node: object | undefined): node is TSStringKeyword {
+    return node instanceof TSStringKeyword
+}
+if (!nodeByType.has(91)) {
+    nodeByType.set(91, TSStringKeyword)
+}