@idlizer/arktscgen 2.1.2

package/build/libarkts-copy/src/generated/peers/TSTypeQuery.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 TSTypeQuery extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 136)
+        super(pointer)
+    }
+    static createTSTypeQuery(exprName?: Expression): TSTypeQuery {
+        return new TSTypeQuery(global.generatedEs2panda._CreateTSTypeQuery(global.context, passNode(exprName)))
+    }
+    static updateTSTypeQuery(original?: TSTypeQuery, exprName?: Expression): TSTypeQuery {
+        return new TSTypeQuery(global.generatedEs2panda._UpdateTSTypeQuery(global.context, passNode(original), passNode(exprName)))
+    }
+    get exprName(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeQueryExprNameConst(global.context, this.peer))
+    }
+}
+export function isTSTypeQuery(node: object | undefined): node is TSTypeQuery {
+    return node instanceof TSTypeQuery
+}
+if (!nodeByType.has(136)) {
+    nodeByType.set(136, TSTypeQuery)
+}

package/build/libarkts-copy/src/generated/peers/TSTypeReference.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 { Identifier } from "./Identifier"
+import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
+import { TypeNode } from "./TypeNode"
+export class TSTypeReference extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 127)
+        super(pointer)
+    }
+    static createTSTypeReference(typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference {
+        return new TSTypeReference(global.generatedEs2panda._CreateTSTypeReference(global.context, passNode(typeName), passNode(typeParams)))
+    }
+    static updateTSTypeReference(original?: TSTypeReference, typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference {
+        return new TSTypeReference(global.generatedEs2panda._UpdateTSTypeReference(global.context, passNode(original), passNode(typeName), passNode(typeParams)))
+    }
+    get typeParams(): TSTypeParameterInstantiation | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeReferenceTypeParamsConst(global.context, this.peer))
+    }
+    get typeName(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeReferenceTypeNameConst(global.context, this.peer))
+    }
+    get baseName(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._TSTypeReferenceBaseNameConst(global.context, this.peer))
+    }
+}
+export function isTSTypeReference(node: object | undefined): node is TSTypeReference {
+    return node instanceof TSTypeReference
+}
+if (!nodeByType.has(127)) {
+    nodeByType.set(127, TSTypeReference)
+}

package/build/libarkts-copy/src/generated/peers/TSUndefinedKeyword.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 TSUndefinedKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 94)
+        super(pointer)
+    }
+    static createTSUndefinedKeyword(): TSUndefinedKeyword {
+        return new TSUndefinedKeyword(global.generatedEs2panda._CreateTSUndefinedKeyword(global.context))
+    }
+    static updateTSUndefinedKeyword(original?: TSUndefinedKeyword): TSUndefinedKeyword {
+        return new TSUndefinedKeyword(global.generatedEs2panda._UpdateTSUndefinedKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSUndefinedKeyword(node: object | undefined): node is TSUndefinedKeyword {
+    return node instanceof TSUndefinedKeyword
+}
+if (!nodeByType.has(94)) {
+    nodeByType.set(94, TSUndefinedKeyword)
+}

package/build/libarkts-copy/src/generated/peers/TSUnionType.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 TSUnionType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 102)
+        super(pointer)
+    }
+    static createTSUnionType(types: readonly TypeNode[]): TSUnionType {
+        return new TSUnionType(global.generatedEs2panda._CreateTSUnionType(global.context, passNodeArray(types), types.length))
+    }
+    static updateTSUnionType(original: TSUnionType | undefined, types: readonly TypeNode[]): TSUnionType {
+        return new TSUnionType(global.generatedEs2panda._UpdateTSUnionType(global.context, passNode(original), passNodeArray(types), types.length))
+    }
+    get types(): readonly TypeNode[] {
+        return unpackNodeArray(global.generatedEs2panda._TSUnionTypeTypesConst(global.context, this.peer))
+    }
+}
+export function isTSUnionType(node: object | undefined): node is TSUnionType {
+    return node instanceof TSUnionType
+}
+if (!nodeByType.has(102)) {
+    nodeByType.set(102, TSUnionType)
+}

package/build/libarkts-copy/src/generated/peers/TSUnknownKeyword.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 TSUnknownKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 95)
+        super(pointer)
+    }
+    static createTSUnknownKeyword(): TSUnknownKeyword {
+        return new TSUnknownKeyword(global.generatedEs2panda._CreateTSUnknownKeyword(global.context))
+    }
+    static updateTSUnknownKeyword(original?: TSUnknownKeyword): TSUnknownKeyword {
+        return new TSUnknownKeyword(global.generatedEs2panda._UpdateTSUnknownKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSUnknownKeyword(node: object | undefined): node is TSUnknownKeyword {
+    return node instanceof TSUnknownKeyword
+}
+if (!nodeByType.has(95)) {
+    nodeByType.set(95, TSUnknownKeyword)
+}

package/build/libarkts-copy/src/generated/peers/TSVoidKeyword.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 TSVoidKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 93)
+        super(pointer)
+    }
+    static createTSVoidKeyword(): TSVoidKeyword {
+        return new TSVoidKeyword(global.generatedEs2panda._CreateTSVoidKeyword(global.context))
+    }
+    static updateTSVoidKeyword(original?: TSVoidKeyword): TSVoidKeyword {
+        return new TSVoidKeyword(global.generatedEs2panda._UpdateTSVoidKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSVoidKeyword(node: object | undefined): node is TSVoidKeyword {
+    return node instanceof TSVoidKeyword
+}
+if (!nodeByType.has(93)) {
+    nodeByType.set(93, TSVoidKeyword)
+}

package/build/libarkts-copy/src/generated/peers/TaggedTemplateExpression.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 { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
+import { TemplateLiteral } from "./TemplateLiteral"
+export class TaggedTemplateExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 140)
+        super(pointer)
+    }
+    static createTaggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression {
+        return new TaggedTemplateExpression(global.generatedEs2panda._CreateTaggedTemplateExpression(global.context, passNode(tag), passNode(quasi), passNode(typeParams)))
+    }
+    static updateTaggedTemplateExpression(original?: TaggedTemplateExpression, tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression {
+        return new TaggedTemplateExpression(global.generatedEs2panda._UpdateTaggedTemplateExpression(global.context, passNode(original), passNode(tag), passNode(quasi), passNode(typeParams)))
+    }
+    get tag(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionTagConst(global.context, this.peer))
+    }
+    get quasi(): TemplateLiteral | undefined {
+        return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionQuasiConst(global.context, this.peer))
+    }
+    get typeParams(): TSTypeParameterInstantiation | undefined {
+        return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionTypeParamsConst(global.context, this.peer))
+    }
+}
+export function isTaggedTemplateExpression(node: object | undefined): node is TaggedTemplateExpression {
+    return node instanceof TaggedTemplateExpression
+}
+if (!nodeByType.has(140)) {
+    nodeByType.set(140, TaggedTemplateExpression)
+}

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

@@ -0,0 +1,59 @@
+/*
+ * 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 TemplateElement extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 141)
+        super(pointer)
+    }
+    static create1TemplateElement(raw: string, cooked: string): TemplateElement {
+        return new TemplateElement(global.generatedEs2panda._CreateTemplateElement1(global.context, raw, cooked))
+    }
+    static updateTemplateElement(original?: TemplateElement): TemplateElement {
+        return new TemplateElement(global.generatedEs2panda._UpdateTemplateElement(global.context, passNode(original)))
+    }
+    static update1TemplateElement(original: TemplateElement | undefined, raw: string, cooked: string): TemplateElement {
+        return new TemplateElement(global.generatedEs2panda._UpdateTemplateElement1(global.context, passNode(original), raw, cooked))
+    }
+    get raw(): string {
+        return unpackString(global.generatedEs2panda._TemplateElementRawConst(global.context, this.peer))
+    }
+    get cooked(): string {
+        return unpackString(global.generatedEs2panda._TemplateElementCookedConst(global.context, this.peer))
+    }
+}
+export function isTemplateElement(node: object | undefined): node is TemplateElement {
+    return node instanceof TemplateElement
+}
+if (!nodeByType.has(141)) {
+    nodeByType.set(141, TemplateElement)
+}

package/build/libarkts-copy/src/generated/peers/TemplateLiteral.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 { TemplateElement } from "./TemplateElement"
+export class TemplateLiteral extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 142)
+        super(pointer)
+    }
+    static createTemplateLiteral(quasis: readonly TemplateElement[], expressions: readonly Expression[], multilineString: string): TemplateLiteral {
+        return new TemplateLiteral(global.generatedEs2panda._CreateTemplateLiteral(global.context, passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString))
+    }
+    static updateTemplateLiteral(original: TemplateLiteral | undefined, quasis: readonly TemplateElement[], expressions: readonly Expression[], multilineString: string): TemplateLiteral {
+        return new TemplateLiteral(global.generatedEs2panda._UpdateTemplateLiteral(global.context, passNode(original), passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString))
+    }
+    get quasis(): readonly TemplateElement[] {
+        return unpackNodeArray(global.generatedEs2panda._TemplateLiteralQuasisConst(global.context, this.peer))
+    }
+    get expressions(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._TemplateLiteralExpressionsConst(global.context, this.peer))
+    }
+    get multilineString(): string {
+        return unpackString(global.generatedEs2panda._TemplateLiteralGetMultilineStringConst(global.context, this.peer))
+    }
+}
+export function isTemplateLiteral(node: object | undefined): node is TemplateLiteral {
+    return node instanceof TemplateLiteral
+}
+if (!nodeByType.has(142)) {
+    nodeByType.set(142, TemplateLiteral)
+}

package/build/libarkts-copy/src/generated/peers/ThisExpression.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 { Expression } from "./Expression"
+export class ThisExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 143)
+        super(pointer)
+    }
+    static createThisExpression(): ThisExpression {
+        return new ThisExpression(global.generatedEs2panda._CreateThisExpression(global.context))
+    }
+    static updateThisExpression(original?: ThisExpression): ThisExpression {
+        return new ThisExpression(global.generatedEs2panda._UpdateThisExpression(global.context, passNode(original)))
+    }
+}
+export function isThisExpression(node: object | undefined): node is ThisExpression {
+    return node instanceof ThisExpression
+}
+if (!nodeByType.has(143)) {
+    nodeByType.set(143, ThisExpression)
+}

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

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { Expression } from "./Expression"
+import { Statement } from "./Statement"
+export class ThrowStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 145)
+        super(pointer)
+    }
+    static createThrowStatement(argument?: Expression): ThrowStatement {
+        return new ThrowStatement(global.generatedEs2panda._CreateThrowStatement(global.context, passNode(argument)))
+    }
+    static updateThrowStatement(original?: ThrowStatement, argument?: Expression): ThrowStatement {
+        return new ThrowStatement(global.generatedEs2panda._UpdateThrowStatement(global.context, passNode(original), passNode(argument)))
+    }
+    get argument(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ThrowStatementArgumentConst(global.context, this.peer))
+    }
+}
+export function isThrowStatement(node: object | undefined): node is ThrowStatement {
+    return node instanceof ThrowStatement
+}
+if (!nodeByType.has(145)) {
+    nodeByType.set(145, ThrowStatement)
+}

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

@@ -0,0 +1,75 @@
+/*
+ * 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 { BlockStatement } from "./BlockStatement"
+import { CatchClause } from "./CatchClause"
+import { Statement } from "./Statement"
+export class TryStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 146)
+        super(pointer)
+    }
+    static create1TryStatement(other?: TryStatement): TryStatement {
+        return new TryStatement(global.generatedEs2panda._CreateTryStatement1(global.context, passNode(other)))
+    }
+    static update1TryStatement(original?: TryStatement, other?: TryStatement): TryStatement {
+        return new TryStatement(global.generatedEs2panda._UpdateTryStatement1(global.context, passNode(original), passNode(other)))
+    }
+    get finallyBlock(): BlockStatement | undefined {
+        return unpackNode(global.generatedEs2panda._TryStatementFinallyBlockConst(global.context, this.peer))
+    }
+    get block(): BlockStatement | undefined {
+        return unpackNode(global.generatedEs2panda._TryStatementBlockConst(global.context, this.peer))
+    }
+    get hasFinalizer(): boolean {
+        return global.generatedEs2panda._TryStatementHasFinalizerConst(global.context, this.peer)
+    }
+    get hasDefaultCatchClause(): boolean {
+        return global.generatedEs2panda._TryStatementHasDefaultCatchClauseConst(global.context, this.peer)
+    }
+    get catchClauses(): readonly CatchClause[] {
+        return unpackNodeArray(global.generatedEs2panda._TryStatementCatchClausesConst(global.context, this.peer))
+    }
+    get finallyCanCompleteNormally(): boolean {
+        return global.generatedEs2panda._TryStatementFinallyCanCompleteNormallyConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setFinallyCanCompleteNormally(finallyCanCompleteNormally: boolean): this {
+        global.generatedEs2panda._TryStatementSetFinallyCanCompleteNormally(global.context, this.peer, finallyCanCompleteNormally)
+        return this
+    }
+}
+export function isTryStatement(node: object | undefined): node is TryStatement {
+    return node instanceof TryStatement
+}
+if (!nodeByType.has(146)) {
+    nodeByType.set(146, TryStatement)
+}