@idlizer/arktscgen 2.1.2

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

@@ -0,0 +1,49 @@
+/*
+ * 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 { Expression } from "./Expression"
+export class TypeNode extends Expression {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._TypeNodeAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._TypeNodeSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isTypeNode(node: object | undefined): node is TypeNode {
+    return node instanceof TypeNode
+}

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

@@ -0,0 +1,39 @@
+/*
+ * 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"
+
+export class TypedAstNode extends AstNode {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}
+export function isTypedAstNode(node: object | undefined): node is TypedAstNode {
+    return node instanceof TypedAstNode
+}

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

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

package/build/libarkts-copy/src/generated/peers/TypeofExpression.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 TypeofExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 144)
+        super(pointer)
+    }
+    static createTypeofExpression(argument?: Expression): TypeofExpression {
+        return new TypeofExpression(global.generatedEs2panda._CreateTypeofExpression(global.context, passNode(argument)))
+    }
+    static updateTypeofExpression(original?: TypeofExpression, argument?: Expression): TypeofExpression {
+        return new TypeofExpression(global.generatedEs2panda._UpdateTypeofExpression(global.context, passNode(original), passNode(argument)))
+    }
+    get argument(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TypeofExpressionArgumentConst(global.context, this.peer))
+    }
+}
+export function isTypeofExpression(node: object | undefined): node is TypeofExpression {
+    return node instanceof TypeofExpression
+}
+if (!nodeByType.has(144)) {
+    nodeByType.set(144, TypeofExpression)
+}

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

@@ -0,0 +1,57 @@
+/*
+ * 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 { Es2pandaTokenType } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+export class UnaryExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 147)
+        super(pointer)
+    }
+    static createUnaryExpression(argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression {
+        return new UnaryExpression(global.generatedEs2panda._CreateUnaryExpression(global.context, passNode(argument), unaryOperator))
+    }
+    static updateUnaryExpression(original: UnaryExpression | undefined, argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression {
+        return new UnaryExpression(global.generatedEs2panda._UpdateUnaryExpression(global.context, passNode(original), passNode(argument), unaryOperator))
+    }
+    get operatorType(): Es2pandaTokenType {
+        return global.generatedEs2panda._UnaryExpressionOperatorTypeConst(global.context, this.peer)
+    }
+    get argument(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._UnaryExpressionArgumentConst(global.context, this.peer))
+    }
+}
+export function isUnaryExpression(node: object | undefined): node is UnaryExpression {
+    return node instanceof UnaryExpression
+}
+if (!nodeByType.has(147)) {
+    nodeByType.set(147, UnaryExpression)
+}

package/build/libarkts-copy/src/generated/peers/UndefinedLiteral.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 { Literal } from "./Literal"
+export class UndefinedLiteral extends Literal {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 51)
+        super(pointer)
+    }
+    static createUndefinedLiteral(): UndefinedLiteral {
+        return new UndefinedLiteral(global.generatedEs2panda._CreateUndefinedLiteral(global.context))
+    }
+    static updateUndefinedLiteral(original?: UndefinedLiteral): UndefinedLiteral {
+        return new UndefinedLiteral(global.generatedEs2panda._UpdateUndefinedLiteral(global.context, passNode(original)))
+    }
+}
+export function isUndefinedLiteral(node: object | undefined): node is UndefinedLiteral {
+    return node instanceof UndefinedLiteral
+}
+if (!nodeByType.has(51)) {
+    nodeByType.set(51, UndefinedLiteral)
+}

package/build/libarkts-copy/src/generated/peers/UpdateExpression.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 { Es2pandaTokenType } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+export class UpdateExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 148)
+        super(pointer)
+    }
+    static createUpdateExpression(argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression {
+        return new UpdateExpression(global.generatedEs2panda._CreateUpdateExpression(global.context, passNode(argument), updateOperator, isPrefix))
+    }
+    static updateUpdateExpression(original: UpdateExpression | undefined, argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression {
+        return new UpdateExpression(global.generatedEs2panda._UpdateUpdateExpression(global.context, passNode(original), passNode(argument), updateOperator, isPrefix))
+    }
+    get operatorType(): Es2pandaTokenType {
+        return global.generatedEs2panda._UpdateExpressionOperatorTypeConst(global.context, this.peer)
+    }
+    get argument(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._UpdateExpressionArgumentConst(global.context, this.peer))
+    }
+    get isPrefix(): boolean {
+        return global.generatedEs2panda._UpdateExpressionIsPrefixConst(global.context, this.peer)
+    }
+}
+export function isUpdateExpression(node: object | undefined): node is UpdateExpression {
+    return node instanceof UpdateExpression
+}
+if (!nodeByType.has(148)) {
+    nodeByType.set(148, UpdateExpression)
+}

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

@@ -0,0 +1,42 @@
+/*
+ * 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"
+
+export class ValidationInfo extends ArktsObject {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+    static createValidationInfo(): ValidationInfo {
+        return new ValidationInfo(global.generatedEs2panda._CreateValidationInfo(global.context))
+    }
+    get fail(): boolean {
+        return global.generatedEs2panda._ValidationInfoFailConst(global.context, this.peer)
+    }
+}

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

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { AnnotationUsage } from "./AnnotationUsage"
+import { Decorator } from "./Decorator"
+import { Es2pandaVariableDeclarationKind } from "./../Es2pandaEnums"
+import { Statement } from "./Statement"
+import { VariableDeclarator } from "./VariableDeclarator"
+export class VariableDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 149)
+        super(pointer)
+    }
+    static createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[]): VariableDeclaration {
+        return new VariableDeclaration(global.generatedEs2panda._CreateVariableDeclaration(global.context, kind, passNodeArray(declarators), declarators.length))
+    }
+    static updateVariableDeclaration(original: VariableDeclaration | undefined, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[]): VariableDeclaration {
+        return new VariableDeclaration(global.generatedEs2panda._UpdateVariableDeclaration(global.context, passNode(original), kind, passNodeArray(declarators), declarators.length))
+    }
+    get declarators(): readonly VariableDeclarator[] {
+        return unpackNodeArray(global.generatedEs2panda._VariableDeclarationDeclaratorsConst(global.context, this.peer))
+    }
+    get kind(): Es2pandaVariableDeclarationKind {
+        return global.generatedEs2panda._VariableDeclarationKindConst(global.context, this.peer)
+    }
+    get decorators(): readonly Decorator[] {
+        return unpackNodeArray(global.generatedEs2panda._VariableDeclarationDecoratorsConst(global.context, this.peer))
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._VariableDeclarationAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._VariableDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isVariableDeclaration(node: object | undefined): node is VariableDeclaration {
+    return node instanceof VariableDeclaration
+}
+if (!nodeByType.has(149)) {
+    nodeByType.set(149, VariableDeclaration)
+}

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

@@ -0,0 +1,69 @@
+/*
+ * 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 { Es2pandaVariableDeclaratorFlag } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { TypedStatement } from "./TypedStatement"
+export class VariableDeclarator extends TypedStatement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 150)
+        super(pointer)
+    }
+    static create1VariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator {
+        return new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator1(global.context, flag, passNode(ident), passNode(init)))
+    }
+    static updateVariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator {
+        return new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator(global.context, passNode(original), flag, passNode(ident)))
+    }
+    static update1VariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator {
+        return new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator1(global.context, passNode(original), flag, passNode(ident), passNode(init)))
+    }
+    get init(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._VariableDeclaratorInitConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setInit(init?: Expression): this {
+        global.generatedEs2panda._VariableDeclaratorSetInit(global.context, this.peer, passNode(init))
+        return this
+    }
+    get id(): Expression {
+        return unpackNonNullableNode(global.generatedEs2panda._VariableDeclaratorIdConst(global.context, this.peer))
+    }
+    get flag(): Es2pandaVariableDeclaratorFlag {
+        return global.generatedEs2panda._VariableDeclaratorFlag(global.context, this.peer)
+    }
+}
+export function isVariableDeclarator(node: object | undefined): node is VariableDeclarator {
+    return node instanceof VariableDeclarator
+}
+if (!nodeByType.has(150)) {
+    nodeByType.set(150, VariableDeclarator)
+}

package/build/libarkts-copy/src/generated/peers/WhileStatement.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"
+import { LoopStatement } from "./LoopStatement"
+import { Statement } from "./Statement"
+export class WhileStatement extends LoopStatement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 151)
+        super(pointer)
+    }
+    static createWhileStatement(test?: Expression, body?: Statement): WhileStatement {
+        return new WhileStatement(global.generatedEs2panda._CreateWhileStatement(global.context, passNode(test), passNode(body)))
+    }
+    static updateWhileStatement(original?: WhileStatement, test?: Expression, body?: Statement): WhileStatement {
+        return new WhileStatement(global.generatedEs2panda._UpdateWhileStatement(global.context, passNode(original), passNode(test), passNode(body)))
+    }
+    get test(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._WhileStatementTestConst(global.context, this.peer))
+    }
+    get body(): Statement | undefined {
+        return unpackNode(global.generatedEs2panda._WhileStatementBodyConst(global.context, this.peer))
+    }
+}
+export function isWhileStatement(node: object | undefined): node is WhileStatement {
+    return node instanceof WhileStatement
+}
+if (!nodeByType.has(151)) {
+    nodeByType.set(151, WhileStatement)
+}

package/build/libarkts-copy/src/generated/peers/YieldExpression.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 { Expression } from "./Expression"
+export class YieldExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 152)
+        super(pointer)
+    }
+    static createYieldExpression(argument: Expression | undefined, isDelegate: boolean): YieldExpression {
+        return new YieldExpression(global.generatedEs2panda._CreateYieldExpression(global.context, passNode(argument), isDelegate))
+    }
+    static updateYieldExpression(original: YieldExpression | undefined, argument: Expression | undefined, isDelegate: boolean): YieldExpression {
+        return new YieldExpression(global.generatedEs2panda._UpdateYieldExpression(global.context, passNode(original), passNode(argument), isDelegate))
+    }
+    get hasDelegate(): boolean {
+        return global.generatedEs2panda._YieldExpressionHasDelegateConst(global.context, this.peer)
+    }
+    get argument(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._YieldExpressionArgumentConst(global.context, this.peer))
+    }
+}
+export function isYieldExpression(node: object | undefined): node is YieldExpression {
+    return node instanceof YieldExpression
+}
+if (!nodeByType.has(152)) {
+    nodeByType.set(152, YieldExpression)
+}