@idlizer/arktscgen 2.1.2

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

@@ -0,0 +1,68 @@
+/*
+ * 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 ETSTypeReferencePart extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 72)
+        super(pointer)
+    }
+    static createETSTypeReferencePart(name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart {
+        return new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart(global.context, passNode(name), passNode(typeParams), passNode(prev)))
+    }
+    static updateETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart {
+        return new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart(global.context, passNode(original), passNode(name), passNode(typeParams), passNode(prev)))
+    }
+    static update1ETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression): ETSTypeReferencePart {
+        return new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart1(global.context, passNode(original), passNode(name)))
+    }
+    get previous(): ETSTypeReferencePart | undefined {
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartPreviousConst(global.context, this.peer))
+    }
+    get typeParams(): TSTypeParameterInstantiation | undefined {
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartTypeParams(global.context, this.peer))
+    }
+    get name(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartNameConst(global.context, this.peer))
+    }
+    get ident(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartGetIdent(global.context, this.peer))
+    }
+}
+export function isETSTypeReferencePart(node: object | undefined): node is ETSTypeReferencePart {
+    return node instanceof ETSTypeReferencePart
+}
+if (!nodeByType.has(72)) {
+    nodeByType.set(72, ETSTypeReferencePart)
+}

package/build/libarkts-copy/src/generated/peers/ETSUndefinedType.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 ETSUndefinedType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 63)
+        super(pointer)
+    }
+    static createETSUndefinedType(): ETSUndefinedType {
+        return new ETSUndefinedType(global.generatedEs2panda._CreateETSUndefinedTypeIr(global.context))
+    }
+    static updateETSUndefinedType(original?: ETSUndefinedType): ETSUndefinedType {
+        return new ETSUndefinedType(global.generatedEs2panda._UpdateETSUndefinedTypeIr(global.context, passNode(original)))
+    }
+}
+export function isETSUndefinedType(node: object | undefined): node is ETSUndefinedType {
+    return node instanceof ETSUndefinedType
+}
+if (!nodeByType.has(63)) {
+    nodeByType.set(63, ETSUndefinedType)
+}

package/build/libarkts-copy/src/generated/peers/ETSUnionType.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 ETSUnionType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 73)
+        super(pointer)
+    }
+    static createETSUnionType(types: readonly TypeNode[]): ETSUnionType {
+        return new ETSUnionType(global.generatedEs2panda._CreateETSUnionTypeIr(global.context, passNodeArray(types), types.length))
+    }
+    static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[]): ETSUnionType {
+        return new ETSUnionType(global.generatedEs2panda._UpdateETSUnionTypeIr(global.context, passNode(original), passNodeArray(types), types.length))
+    }
+    get types(): readonly TypeNode[] {
+        return unpackNodeArray(global.generatedEs2panda._ETSUnionTypeIrTypesConst(global.context, this.peer))
+    }
+}
+export function isETSUnionType(node: object | undefined): node is ETSUnionType {
+    return node instanceof ETSUnionType
+}
+if (!nodeByType.has(73)) {
+    nodeByType.set(73, ETSUnionType)
+}

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

@@ -0,0 +1,55 @@
+/*
+ * 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 { ETSTypeReference } from "./ETSTypeReference"
+import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
+import { TypeNode } from "./TypeNode"
+export class ETSWildcardType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 67)
+        super(pointer)
+    }
+    static createETSWildcardType(typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType {
+        return new ETSWildcardType(global.generatedEs2panda._CreateETSWildcardType(global.context, passNode(typeReference), flags))
+    }
+    static updateETSWildcardType(original: ETSWildcardType | undefined, typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType {
+        return new ETSWildcardType(global.generatedEs2panda._UpdateETSWildcardType(global.context, passNode(original), passNode(typeReference), flags))
+    }
+    get typeReference(): ETSTypeReference | undefined {
+        return unpackNode(global.generatedEs2panda._ETSWildcardTypeTypeReferenceConst(global.context, this.peer))
+    }
+}
+export function isETSWildcardType(node: object | undefined): node is ETSWildcardType {
+    return node instanceof ETSWildcardType
+}
+if (!nodeByType.has(67)) {
+    nodeByType.set(67, ETSWildcardType)
+}

package/build/libarkts-copy/src/generated/peers/EmptyStatement.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 { Statement } from "./Statement"
+export class EmptyStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 25)
+        super(pointer)
+    }
+    static createEmptyStatement(): EmptyStatement {
+        return new EmptyStatement(global.generatedEs2panda._CreateEmptyStatement(global.context))
+    }
+    static updateEmptyStatement(original?: EmptyStatement): EmptyStatement {
+        return new EmptyStatement(global.generatedEs2panda._UpdateEmptyStatement(global.context, passNode(original)))
+    }
+}
+export function isEmptyStatement(node: object | undefined): node is EmptyStatement {
+    return node instanceof EmptyStatement
+}
+if (!nodeByType.has(25)) {
+    nodeByType.set(25, EmptyStatement)
+}

package/build/libarkts-copy/src/generated/peers/ExportAllDeclaration.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 { Identifier } from "./Identifier"
+import { Statement } from "./Statement"
+import { StringLiteral } from "./StringLiteral"
+export class ExportAllDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 26)
+        super(pointer)
+    }
+    static createExportAllDeclaration(source?: StringLiteral, exported?: Identifier): ExportAllDeclaration {
+        return new ExportAllDeclaration(global.generatedEs2panda._CreateExportAllDeclaration(global.context, passNode(source), passNode(exported)))
+    }
+    static updateExportAllDeclaration(original?: ExportAllDeclaration, source?: StringLiteral, exported?: Identifier): ExportAllDeclaration {
+        return new ExportAllDeclaration(global.generatedEs2panda._UpdateExportAllDeclaration(global.context, passNode(original), passNode(source), passNode(exported)))
+    }
+    get source(): StringLiteral | undefined {
+        return unpackNode(global.generatedEs2panda._ExportAllDeclarationSourceConst(global.context, this.peer))
+    }
+    get exported(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ExportAllDeclarationExportedConst(global.context, this.peer))
+    }
+}
+export function isExportAllDeclaration(node: object | undefined): node is ExportAllDeclaration {
+    return node instanceof ExportAllDeclaration
+}
+if (!nodeByType.has(26)) {
+    nodeByType.set(26, ExportAllDeclaration)
+}

package/build/libarkts-copy/src/generated/peers/ExportDefaultDeclaration.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 { Statement } from "./Statement"
+export class ExportDefaultDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 27)
+        super(pointer)
+    }
+    static createExportDefaultDeclaration(decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration {
+        return new ExportDefaultDeclaration(global.generatedEs2panda._CreateExportDefaultDeclaration(global.context, passNode(decl), exportEquals))
+    }
+    static updateExportDefaultDeclaration(original: ExportDefaultDeclaration | undefined, decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration {
+        return new ExportDefaultDeclaration(global.generatedEs2panda._UpdateExportDefaultDeclaration(global.context, passNode(original), passNode(decl), exportEquals))
+    }
+    get decl(): AstNode | undefined {
+        return unpackNode(global.generatedEs2panda._ExportDefaultDeclarationDeclConst(global.context, this.peer))
+    }
+    get isExportEquals(): boolean {
+        return global.generatedEs2panda._ExportDefaultDeclarationIsExportEqualsConst(global.context, this.peer)
+    }
+}
+export function isExportDefaultDeclaration(node: object | undefined): node is ExportDefaultDeclaration {
+    return node instanceof ExportDefaultDeclaration
+}
+if (!nodeByType.has(27)) {
+    nodeByType.set(27, ExportDefaultDeclaration)
+}

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

@@ -0,0 +1,73 @@
+/*
+ * 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 { ExportSpecifier } from "./ExportSpecifier"
+import { Statement } from "./Statement"
+import { StringLiteral } from "./StringLiteral"
+export class ExportNamedDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 28)
+        super(pointer)
+    }
+    static createExportNamedDeclaration(source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration {
+        return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length))
+    }
+    static updateExportNamedDeclaration(original: ExportNamedDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration {
+        return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length))
+    }
+    static create1ExportNamedDeclaration(decl: AstNode | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration {
+        return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration1(global.context, passNode(decl), passNodeArray(specifiers), specifiers.length))
+    }
+    static update1ExportNamedDeclaration(original: ExportNamedDeclaration | undefined, decl: AstNode | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration {
+        return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration1(global.context, passNode(original), passNode(decl), passNodeArray(specifiers), specifiers.length))
+    }
+    static create2ExportNamedDeclaration(decl?: AstNode): ExportNamedDeclaration {
+        return new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration2(global.context, passNode(decl)))
+    }
+    static update2ExportNamedDeclaration(original?: ExportNamedDeclaration, decl?: AstNode): ExportNamedDeclaration {
+        return new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration2(global.context, passNode(original), passNode(decl)))
+    }
+    get decl(): AstNode | undefined {
+        return unpackNode(global.generatedEs2panda._ExportNamedDeclarationDeclConst(global.context, this.peer))
+    }
+    get source(): StringLiteral | undefined {
+        return unpackNode(global.generatedEs2panda._ExportNamedDeclarationSourceConst(global.context, this.peer))
+    }
+    get specifiers(): readonly ExportSpecifier[] {
+        return unpackNodeArray(global.generatedEs2panda._ExportNamedDeclarationSpecifiersConst(global.context, this.peer))
+    }
+}
+export function isExportNamedDeclaration(node: object | undefined): node is ExportNamedDeclaration {
+    return node instanceof ExportNamedDeclaration
+}
+if (!nodeByType.has(28)) {
+    nodeByType.set(28, ExportNamedDeclaration)
+}

package/build/libarkts-copy/src/generated/peers/ExportSpecifier.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 { Identifier } from "./Identifier"
+import { Statement } from "./Statement"
+export class ExportSpecifier extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 29)
+        super(pointer)
+    }
+    static createExportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier {
+        return new ExportSpecifier(global.generatedEs2panda._CreateExportSpecifier(global.context, passNode(local), passNode(exported)))
+    }
+    static updateExportSpecifier(original?: ExportSpecifier, local?: Identifier, exported?: Identifier): ExportSpecifier {
+        return new ExportSpecifier(global.generatedEs2panda._UpdateExportSpecifier(global.context, passNode(original), passNode(local), passNode(exported)))
+    }
+    get local(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ExportSpecifierLocalConst(global.context, this.peer))
+    }
+    get exported(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ExportSpecifierExportedConst(global.context, this.peer))
+    }
+}
+export function isExportSpecifier(node: object | undefined): node is ExportSpecifier {
+    return node instanceof ExportSpecifier
+}
+if (!nodeByType.has(29)) {
+    nodeByType.set(29, ExportSpecifier)
+}

package/build/libarkts-copy/src/generated/peers/Expression.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 { AnnotatedExpression } from "./AnnotatedExpression"
+import { Literal } from "./Literal"
+import { TypeNode } from "./TypeNode"
+import { TypedAstNode } from "./TypedAstNode"
+export class Expression extends TypedAstNode {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+    get isGrouped(): boolean {
+        return global.generatedEs2panda._ExpressionIsGroupedConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setGrouped(): this {
+        global.generatedEs2panda._ExpressionSetGrouped(global.context, this.peer)
+        return this
+    }
+    get asLiteral(): Literal | undefined {
+        return unpackNode(global.generatedEs2panda._ExpressionAsLiteralConst(global.context, this.peer))
+    }
+    get isLiteral(): boolean {
+        return global.generatedEs2panda._ExpressionIsLiteralConst(global.context, this.peer)
+    }
+    get isTypeNode(): boolean {
+        return global.generatedEs2panda._ExpressionIsTypeNodeConst(global.context, this.peer)
+    }
+    get isAnnotatedExpression(): boolean {
+        return global.generatedEs2panda._ExpressionIsAnnotatedExpressionConst(global.context, this.peer)
+    }
+    get asTypeNode(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ExpressionAsTypeNodeConst(global.context, this.peer))
+    }
+    get asAnnotatedExpression(): AnnotatedExpression | undefined {
+        return unpackNode(global.generatedEs2panda._ExpressionAsAnnotatedExpressionConst(global.context, this.peer))
+    }
+    get isBrokenExpression(): boolean {
+        return global.generatedEs2panda._ExpressionIsBrokenExpressionConst(global.context, this.peer)
+    }
+    get toString(): string {
+        return unpackString(global.generatedEs2panda._ExpressionToStringConst(global.context, this.peer))
+    }
+}
+export function isExpression(node: object | undefined): node is Expression {
+    return node instanceof Expression
+}

package/build/libarkts-copy/src/generated/peers/ExpressionStatement.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"
+import { Statement } from "./Statement"
+export class ExpressionStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 30)
+        super(pointer)
+    }
+    static createExpressionStatement(expr?: Expression): ExpressionStatement {
+        return new ExpressionStatement(global.generatedEs2panda._CreateExpressionStatement(global.context, passNode(expr)))
+    }
+    static updateExpressionStatement(original?: ExpressionStatement, expr?: Expression): ExpressionStatement {
+        return new ExpressionStatement(global.generatedEs2panda._UpdateExpressionStatement(global.context, passNode(original), passNode(expr)))
+    }
+    get expression(): Expression {
+        return unpackNonNullableNode(global.generatedEs2panda._ExpressionStatementGetExpressionConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setExpression(expr?: Expression): this {
+        global.generatedEs2panda._ExpressionStatementSetExpression(global.context, this.peer, passNode(expr))
+        return this
+    }
+}
+export function isExpressionStatement(node: object | undefined): node is ExpressionStatement {
+    return node instanceof ExpressionStatement
+}
+if (!nodeByType.has(30)) {
+    nodeByType.set(30, ExpressionStatement)
+}