@idlizer/arktscgen 2.1.2

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { Expression } from "./Expression"
+import { Identifier } from "./Identifier"
+import { Statement } from "./Statement"
+export class AnnotationUsage extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 2)
+        super(pointer)
+    }
+    static create1AnnotationUsage(expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage {
+        return new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsageIr1(global.context, passNode(expr), passNodeArray(properties), properties.length))
+    }
+    static updateAnnotationUsage(original?: AnnotationUsage, expr?: Expression): AnnotationUsage {
+        return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsageIr(global.context, passNode(original), passNode(expr)))
+    }
+    static update1AnnotationUsage(original: AnnotationUsage | undefined, expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage {
+        return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsageIr1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length))
+    }
+    get expr(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._AnnotationUsageIrExpr(global.context, this.peer))
+    }
+    get properties(): readonly AstNode[] {
+        return unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrPropertiesConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    addProperty(property?: AstNode): this {
+        global.generatedEs2panda._AnnotationUsageIrAddProperty(global.context, this.peer, passNode(property))
+        return this
+    }
+    /** @deprecated */
+    setProperties(properties: readonly AstNode[]): this {
+        global.generatedEs2panda._AnnotationUsageIrSetProperties(global.context, this.peer, passNodeArray(properties), properties.length)
+        return this
+    }
+    get baseName(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._AnnotationUsageIrGetBaseNameConst(global.context, this.peer))
+    }
+}
+export function isAnnotationUsage(node: object | undefined): node is AnnotationUsage {
+    return node instanceof AnnotationUsage
+}
+if (!nodeByType.has(2)) {
+    nodeByType.set(2, AnnotationUsage)
+}

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

@@ -0,0 +1,98 @@
+/*
+ * 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 { Decorator } from "./Decorator"
+import { Expression } from "./Expression"
+import { TypeNode } from "./TypeNode"
+import { ValidationInfo } from "./ValidationInfo"
+export class ArrayExpression extends AnnotatedExpression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 156)
+        super(pointer)
+    }
+    static create1ArrayExpression(nodeType: Es2pandaAstNodeType, elements: readonly Expression[], trailingComma: boolean): ArrayExpression {
+        return new ArrayExpression(global.generatedEs2panda._CreateArrayExpression1(global.context, nodeType, passNodeArray(elements), elements.length, trailingComma))
+    }
+    static updateArrayExpression(original: ArrayExpression | undefined, elements: readonly Expression[]): ArrayExpression {
+        return new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression(global.context, passNode(original), passNodeArray(elements), elements.length))
+    }
+    static update1ArrayExpression(original: ArrayExpression | undefined, nodeType: Es2pandaAstNodeType, elements: readonly Expression[], trailingComma: boolean): ArrayExpression {
+        return new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression1(global.context, passNode(original), nodeType, passNodeArray(elements), elements.length, trailingComma))
+    }
+    get elements(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._ArrayExpressionElementsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setElements(elements: readonly Expression[]): this {
+        global.generatedEs2panda._ArrayExpressionSetElements(global.context, this.peer, passNodeArray(elements), elements.length)
+        return this
+    }
+    get isDeclaration(): boolean {
+        return global.generatedEs2panda._ArrayExpressionIsDeclarationConst(global.context, this.peer)
+    }
+    get isOptional(): boolean {
+        return global.generatedEs2panda._ArrayExpressionIsOptionalConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setDeclaration(): this {
+        global.generatedEs2panda._ArrayExpressionSetDeclaration(global.context, this.peer)
+        return this
+    }
+    /** @deprecated */
+    setOptional(optional_arg: boolean): this {
+        global.generatedEs2panda._ArrayExpressionSetOptional(global.context, this.peer, optional_arg)
+        return this
+    }
+    get decorators(): readonly Decorator[] {
+        return unpackNodeArray(global.generatedEs2panda._ArrayExpressionDecoratorsConst(global.context, this.peer))
+    }
+    get convertibleToArrayPattern(): boolean {
+        return global.generatedEs2panda._ArrayExpressionConvertibleToArrayPattern(global.context, this.peer)
+    }
+    get validateExpression(): ValidationInfo | undefined {
+        return new ValidationInfo(global.generatedEs2panda._ArrayExpressionValidateExpression(global.context, this.peer))
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ArrayExpressionTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTsTypeAnnotation(typeAnnotation?: TypeNode): this {
+        global.generatedEs2panda._ArrayExpressionSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
+        return this
+    }
+}
+export function isArrayExpression(node: object | undefined): node is ArrayExpression {
+    return node instanceof ArrayExpression
+}
+if (!nodeByType.has(156)) {
+    nodeByType.set(156, ArrayExpression)
+}

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

@@ -0,0 +1,70 @@
+/*
+ * 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"
+import { ScriptFunction } from "./ScriptFunction"
+import { TypeNode } from "./TypeNode"
+export class ArrowFunctionExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 0)
+        super(pointer)
+    }
+    static createArrowFunctionExpression(func?: ScriptFunction): ArrowFunctionExpression {
+        return new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func)))
+    }
+    static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction): ArrowFunctionExpression {
+        return new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression(global.context, passNode(original), passNode(func)))
+    }
+    static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression): ArrowFunctionExpression {
+        return new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other)))
+    }
+    get function(): ScriptFunction {
+        return unpackNonNullableNode(global.generatedEs2panda._ArrowFunctionExpressionFunctionConst(global.context, this.peer))
+    }
+    get createTypeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ArrowFunctionExpressionCreateTypeAnnotation(global.context, this.peer))
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._ArrowFunctionExpressionAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._ArrowFunctionExpressionSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isArrowFunctionExpression(node: object | undefined): node is ArrowFunctionExpression {
+    return node instanceof ArrowFunctionExpression
+}
+if (!nodeByType.has(0)) {
+    nodeByType.set(0, ArrowFunctionExpression)
+}

package/build/libarkts-copy/src/generated/peers/AssertStatement.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 { Expression } from "./Expression"
+import { Statement } from "./Statement"
+export class AssertStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 3)
+        super(pointer)
+    }
+    static createAssertStatement(test?: Expression, second?: Expression): AssertStatement {
+        return new AssertStatement(global.generatedEs2panda._CreateAssertStatement(global.context, passNode(test), passNode(second)))
+    }
+    static updateAssertStatement(original?: AssertStatement, test?: Expression, second?: Expression): AssertStatement {
+        return new AssertStatement(global.generatedEs2panda._UpdateAssertStatement(global.context, passNode(original), passNode(test), passNode(second)))
+    }
+    get test(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._AssertStatementTestConst(global.context, this.peer))
+    }
+    get second(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._AssertStatementSecondConst(global.context, this.peer))
+    }
+}
+export function isAssertStatement(node: object | undefined): node is AssertStatement {
+    return node instanceof AssertStatement
+}
+if (!nodeByType.has(3)) {
+    nodeByType.set(3, AssertStatement)
+}

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

@@ -0,0 +1,95 @@
+/*
+ * 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 AssignmentExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 158)
+        super(pointer)
+    }
+    static create1AssignmentExpression(type: Es2pandaAstNodeType, left: Expression | undefined, right: Expression | undefined, assignmentOperator: Es2pandaTokenType): AssignmentExpression {
+        return new AssignmentExpression(global.generatedEs2panda._CreateAssignmentExpression1(global.context, type, passNode(left), passNode(right), assignmentOperator))
+    }
+    static updateAssignmentExpression(original: AssignmentExpression | undefined, left: Expression | undefined, right: Expression | undefined, assignmentOperator: Es2pandaTokenType): AssignmentExpression {
+        return new AssignmentExpression(global.generatedEs2panda._UpdateAssignmentExpression(global.context, passNode(original), passNode(left), passNode(right), assignmentOperator))
+    }
+    static update1AssignmentExpression(original: AssignmentExpression | undefined, type: Es2pandaAstNodeType, left: Expression | undefined, right: Expression | undefined, assignmentOperator: Es2pandaTokenType): AssignmentExpression {
+        return new AssignmentExpression(global.generatedEs2panda._UpdateAssignmentExpression1(global.context, passNode(original), type, passNode(left), passNode(right), assignmentOperator))
+    }
+    get left(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._AssignmentExpressionLeftConst(global.context, this.peer))
+    }
+    get right(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._AssignmentExpressionRightConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setRight(expr?: Expression): this {
+        global.generatedEs2panda._AssignmentExpressionSetRight(global.context, this.peer, passNode(expr))
+        return this
+    }
+    /** @deprecated */
+    setLeft(expr?: Expression): this {
+        global.generatedEs2panda._AssignmentExpressionSetLeft(global.context, this.peer, passNode(expr))
+        return this
+    }
+    get result(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._AssignmentExpressionResultConst(global.context, this.peer))
+    }
+    get operatorType(): Es2pandaTokenType {
+        return global.generatedEs2panda._AssignmentExpressionOperatorTypeConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setResult(expr?: Expression): this {
+        global.generatedEs2panda._AssignmentExpressionSetResult(global.context, this.peer, passNode(expr))
+        return this
+    }
+    get isLogicalExtended(): boolean {
+        return global.generatedEs2panda._AssignmentExpressionIsLogicalExtendedConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setIgnoreConstAssign(): this {
+        global.generatedEs2panda._AssignmentExpressionSetIgnoreConstAssign(global.context, this.peer)
+        return this
+    }
+    get isIgnoreConstAssign(): boolean {
+        return global.generatedEs2panda._AssignmentExpressionIsIgnoreConstAssignConst(global.context, this.peer)
+    }
+    get convertibleToAssignmentPatternRight(): boolean {
+        return global.generatedEs2panda._AssignmentExpressionConvertibleToAssignmentPatternRight(global.context, this.peer)
+    }
+}
+export function isAssignmentExpression(node: object | undefined): node is AssignmentExpression {
+    return node instanceof AssignmentExpression
+}
+if (!nodeByType.has(158)) {
+    nodeByType.set(158, AssignmentExpression)
+}

package/build/libarkts-copy/src/generated/peers/AstDumper.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 AstDumper extends ArktsObject {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+    static createAstDumper(node: AstNode | undefined, sourceCode: string): AstDumper {
+        return new AstDumper(global.generatedEs2panda._CreateAstDumper(global.context, passNode(node), sourceCode))
+    }
+    get str(): string {
+        return unpackString(global.generatedEs2panda._AstDumperStrConst(global.context, this.peer))
+    }
+}

package/build/libarkts-copy/src/generated/peers/AwaitExpression.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 AwaitExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 4)
+        super(pointer)
+    }
+    static createAwaitExpression(argument?: Expression): AwaitExpression {
+        return new AwaitExpression(global.generatedEs2panda._CreateAwaitExpression(global.context, passNode(argument)))
+    }
+    static updateAwaitExpression(original?: AwaitExpression, argument?: Expression): AwaitExpression {
+        return new AwaitExpression(global.generatedEs2panda._UpdateAwaitExpression(global.context, passNode(original), passNode(argument)))
+    }
+    get argument(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._AwaitExpressionArgumentConst(global.context, this.peer))
+    }
+}
+export function isAwaitExpression(node: object | undefined): node is AwaitExpression {
+    return node instanceof AwaitExpression
+}
+if (!nodeByType.has(4)) {
+    nodeByType.set(4, AwaitExpression)
+}

package/build/libarkts-copy/src/generated/peers/BigIntLiteral.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 { Literal } from "./Literal"
+export class BigIntLiteral extends Literal {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 5)
+        super(pointer)
+    }
+    static createBigIntLiteral(src: string): BigIntLiteral {
+        return new BigIntLiteral(global.generatedEs2panda._CreateBigIntLiteral(global.context, src))
+    }
+    static updateBigIntLiteral(original: BigIntLiteral | undefined, src: string): BigIntLiteral {
+        return new BigIntLiteral(global.generatedEs2panda._UpdateBigIntLiteral(global.context, passNode(original), src))
+    }
+    get str(): string {
+        return unpackString(global.generatedEs2panda._BigIntLiteralStrConst(global.context, this.peer))
+    }
+}
+export function isBigIntLiteral(node: object | undefined): node is BigIntLiteral {
+    return node instanceof BigIntLiteral
+}
+if (!nodeByType.has(5)) {
+    nodeByType.set(5, BigIntLiteral)
+}

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

@@ -0,0 +1,95 @@
+/*
+ * 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 BinaryExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 6)
+        super(pointer)
+    }
+    static createBinaryExpression(left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression {
+        return new BinaryExpression(global.generatedEs2panda._CreateBinaryExpression(global.context, passNode(left), passNode(right), operatorType))
+    }
+    static updateBinaryExpression(original: BinaryExpression | undefined, left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression {
+        return new BinaryExpression(global.generatedEs2panda._UpdateBinaryExpression(global.context, passNode(original), passNode(left), passNode(right), operatorType))
+    }
+    get left(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._BinaryExpressionLeftConst(global.context, this.peer))
+    }
+    get right(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._BinaryExpressionRightConst(global.context, this.peer))
+    }
+    get result(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._BinaryExpressionResultConst(global.context, this.peer))
+    }
+    get operatorType(): Es2pandaTokenType {
+        return global.generatedEs2panda._BinaryExpressionOperatorTypeConst(global.context, this.peer)
+    }
+    get isLogical(): boolean {
+        return global.generatedEs2panda._BinaryExpressionIsLogicalConst(global.context, this.peer)
+    }
+    get isLogicalExtended(): boolean {
+        return global.generatedEs2panda._BinaryExpressionIsLogicalExtendedConst(global.context, this.peer)
+    }
+    get isBitwise(): boolean {
+        return global.generatedEs2panda._BinaryExpressionIsBitwiseConst(global.context, this.peer)
+    }
+    get isArithmetic(): boolean {
+        return global.generatedEs2panda._BinaryExpressionIsArithmeticConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setLeft(expr?: Expression): this {
+        global.generatedEs2panda._BinaryExpressionSetLeft(global.context, this.peer, passNode(expr))
+        return this
+    }
+    /** @deprecated */
+    setRight(expr?: Expression): this {
+        global.generatedEs2panda._BinaryExpressionSetRight(global.context, this.peer, passNode(expr))
+        return this
+    }
+    /** @deprecated */
+    setResult(expr?: Expression): this {
+        global.generatedEs2panda._BinaryExpressionSetResult(global.context, this.peer, passNode(expr))
+        return this
+    }
+    /** @deprecated */
+    setOperator(operatorType: Es2pandaTokenType): this {
+        global.generatedEs2panda._BinaryExpressionSetOperator(global.context, this.peer, operatorType)
+        return this
+    }
+}
+export function isBinaryExpression(node: object | undefined): node is BinaryExpression {
+    return node instanceof BinaryExpression
+}
+if (!nodeByType.has(6)) {
+    nodeByType.set(6, BinaryExpression)
+}