@idlizer/arktscgen 2.1.2

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

@@ -0,0 +1,82 @@
+/*
+ * 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 { Es2pandaPropertyKind } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { ValidationInfo } from "./ValidationInfo"
+export class Property extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 55)
+        super(pointer)
+    }
+    static create1Property(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property {
+        return new Property(global.generatedEs2panda._CreateProperty1(global.context, kind, passNode(key), passNode(value), isMethod, isComputed))
+    }
+    static updateProperty(original?: Property, key?: Expression, value?: Expression): Property {
+        return new Property(global.generatedEs2panda._UpdateProperty(global.context, passNode(original), passNode(key), passNode(value)))
+    }
+    static update1Property(original: Property | undefined, kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property {
+        return new Property(global.generatedEs2panda._UpdateProperty1(global.context, passNode(original), kind, passNode(key), passNode(value), isMethod, isComputed))
+    }
+    get key(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._PropertyKeyConst(global.context, this.peer))
+    }
+    get value(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._PropertyValueConst(global.context, this.peer))
+    }
+    get kind(): Es2pandaPropertyKind {
+        return global.generatedEs2panda._PropertyKindConst(global.context, this.peer)
+    }
+    get isMethod(): boolean {
+        return global.generatedEs2panda._PropertyIsMethodConst(global.context, this.peer)
+    }
+    get isShorthand(): boolean {
+        return global.generatedEs2panda._PropertyIsShorthandConst(global.context, this.peer)
+    }
+    get isComputed(): boolean {
+        return global.generatedEs2panda._PropertyIsComputedConst(global.context, this.peer)
+    }
+    get isAccessor(): boolean {
+        return global.generatedEs2panda._PropertyIsAccessorConst(global.context, this.peer)
+    }
+    get convertibleToPatternProperty(): boolean {
+        return global.generatedEs2panda._PropertyConvertibleToPatternProperty(global.context, this.peer)
+    }
+    get validateExpression(): ValidationInfo | undefined {
+        return new ValidationInfo(global.generatedEs2panda._PropertyValidateExpression(global.context, this.peer))
+    }
+}
+export function isProperty(node: object | undefined): node is Property {
+    return node instanceof Property
+}
+if (!nodeByType.has(55)) {
+    nodeByType.set(55, Property)
+}

package/build/libarkts-copy/src/generated/peers/RegExpLiteral.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 { Es2pandaRegExpFlags } from "./../Es2pandaEnums"
+import { Literal } from "./Literal"
+export class RegExpLiteral extends Literal {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 56)
+        super(pointer)
+    }
+    static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral {
+        return new RegExpLiteral(global.generatedEs2panda._CreateRegExpLiteral(global.context, pattern, flags, flagsStr))
+    }
+    static updateRegExpLiteral(original: RegExpLiteral | undefined, pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral {
+        return new RegExpLiteral(global.generatedEs2panda._UpdateRegExpLiteral(global.context, passNode(original), pattern, flags, flagsStr))
+    }
+    get pattern(): string {
+        return unpackString(global.generatedEs2panda._RegExpLiteralPatternConst(global.context, this.peer))
+    }
+    get flags(): Es2pandaRegExpFlags {
+        return global.generatedEs2panda._RegExpLiteralFlagsConst(global.context, this.peer)
+    }
+}
+export function isRegExpLiteral(node: object | undefined): node is RegExpLiteral {
+    return node instanceof RegExpLiteral
+}
+if (!nodeByType.has(56)) {
+    nodeByType.set(56, RegExpLiteral)
+}

package/build/libarkts-copy/src/generated/peers/ReturnStatement.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 { Statement } from "./Statement"
+export class ReturnStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 58)
+        super(pointer)
+    }
+    static create1ReturnStatement(argument?: Expression): ReturnStatement {
+        return new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument)))
+    }
+    static updateReturnStatement(original?: ReturnStatement): ReturnStatement {
+        return new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original)))
+    }
+    static update1ReturnStatement(original?: ReturnStatement, argument?: Expression): ReturnStatement {
+        return new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument)))
+    }
+    get argument(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ReturnStatementArgumentConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setArgument(arg?: Expression): this {
+        global.generatedEs2panda._ReturnStatementSetArgument(global.context, this.peer, passNode(arg))
+        return this
+    }
+}
+export function isReturnStatement(node: object | undefined): node is ReturnStatement {
+    return node instanceof ReturnStatement
+}
+if (!nodeByType.has(58)) {
+    nodeByType.set(58, ReturnStatement)
+}

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

@@ -0,0 +1,201 @@
+/*
+ * 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 { Es2pandaModifierFlags } from "./../Es2pandaEnums"
+import { Es2pandaScriptFunctionFlags } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { FunctionSignature } from "./FunctionSignature"
+import { Identifier } from "./Identifier"
+import { ReturnStatement } from "./ReturnStatement"
+import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
+import { TypeNode } from "./TypeNode"
+export class ScriptFunction extends AstNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 59)
+        super(pointer)
+    }
+    static createScriptFunction(databody: AstNode | undefined, datasignature: FunctionSignature | undefined, datafuncFlags: number, dataflags: number): ScriptFunction {
+        return new ScriptFunction(global.generatedEs2panda._CreateScriptFunction(global.context, passNode(databody), passNode(datasignature), datafuncFlags, dataflags))
+    }
+    static updateScriptFunction(original: ScriptFunction | undefined, databody: AstNode | undefined, datasignature: FunctionSignature | undefined, datafuncFlags: number, dataflags: number): ScriptFunction {
+        return new ScriptFunction(global.generatedEs2panda._UpdateScriptFunction(global.context, passNode(original), passNode(databody), passNode(datasignature), datafuncFlags, dataflags))
+    }
+    get id(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ScriptFunctionIdConst(global.context, this.peer))
+    }
+    get params(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionParamsConst(global.context, this.peer))
+    }
+    get returnStatements(): readonly ReturnStatement[] {
+        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionReturnStatementsConst(global.context, this.peer))
+    }
+    get typeParams(): TSTypeParameterDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._ScriptFunctionTypeParamsConst(global.context, this.peer))
+    }
+    get body(): AstNode | undefined {
+        return unpackNode(global.generatedEs2panda._ScriptFunctionBodyConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    addReturnStatement(returnStatement?: ReturnStatement): this {
+        global.generatedEs2panda._ScriptFunctionAddReturnStatement(global.context, this.peer, passNode(returnStatement))
+        return this
+    }
+    /** @deprecated */
+    setBody(body?: AstNode): this {
+        global.generatedEs2panda._ScriptFunctionSetBody(global.context, this.peer, passNode(body))
+        return this
+    }
+    get returnTypeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ScriptFunctionReturnTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setReturnTypeAnnotation(node?: TypeNode): this {
+        global.generatedEs2panda._ScriptFunctionSetReturnTypeAnnotation(global.context, this.peer, passNode(node))
+        return this
+    }
+    get isEntryPoint(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsEntryPointConst(global.context, this.peer)
+    }
+    get isGenerator(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsGeneratorConst(global.context, this.peer)
+    }
+    get isAsyncFunc(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsAsyncFuncConst(global.context, this.peer)
+    }
+    get isAsyncImplFunc(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsAsyncImplFuncConst(global.context, this.peer)
+    }
+    get isArrow(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsArrowConst(global.context, this.peer)
+    }
+    get isOverload(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsOverloadConst(global.context, this.peer)
+    }
+    get isExternalOverload(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsExternalOverloadConst(global.context, this.peer)
+    }
+    get isConstructor(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsConstructorConst(global.context, this.peer)
+    }
+    get isGetter(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsGetterConst(global.context, this.peer)
+    }
+    get isSetter(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsSetterConst(global.context, this.peer)
+    }
+    get isExtensionAccessor(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsExtensionAccessorConst(global.context, this.peer)
+    }
+    get isMethod(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsMethodConst(global.context, this.peer)
+    }
+    get isProxy(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsProxyConst(global.context, this.peer)
+    }
+    get isStaticBlock(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsStaticBlockConst(global.context, this.peer)
+    }
+    get isEnum(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsEnumConst(global.context, this.peer)
+    }
+    get isHidden(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsHiddenConst(global.context, this.peer)
+    }
+    get isExternal(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsExternalConst(global.context, this.peer)
+    }
+    get isImplicitSuperCallNeeded(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsImplicitSuperCallNeededConst(global.context, this.peer)
+    }
+    get hasBody(): boolean {
+        return global.generatedEs2panda._ScriptFunctionHasBodyConst(global.context, this.peer)
+    }
+    get hasRestParameter(): boolean {
+        return global.generatedEs2panda._ScriptFunctionHasRestParameterConst(global.context, this.peer)
+    }
+    get hasReturnStatement(): boolean {
+        return global.generatedEs2panda._ScriptFunctionHasReturnStatementConst(global.context, this.peer)
+    }
+    get hasThrowStatement(): boolean {
+        return global.generatedEs2panda._ScriptFunctionHasThrowStatementConst(global.context, this.peer)
+    }
+    get isThrowing(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsThrowingConst(global.context, this.peer)
+    }
+    get isRethrowing(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsRethrowingConst(global.context, this.peer)
+    }
+    get isDynamic(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsDynamicConst(global.context, this.peer)
+    }
+    get isExtensionMethod(): boolean {
+        return global.generatedEs2panda._ScriptFunctionIsExtensionMethodConst(global.context, this.peer)
+    }
+    get flags(): Es2pandaScriptFunctionFlags {
+        return global.generatedEs2panda._ScriptFunctionFlagsConst(global.context, this.peer)
+    }
+    get hasReceiver(): boolean {
+        return global.generatedEs2panda._ScriptFunctionHasReceiverConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setIdent(id: Identifier): this {
+        global.generatedEs2panda._ScriptFunctionSetIdent(global.context, this.peer, passNode(id))
+        return this
+    }
+    /** @deprecated */
+    addFlag(flags: Es2pandaScriptFunctionFlags): this {
+        global.generatedEs2panda._ScriptFunctionAddFlag(global.context, this.peer, flags)
+        return this
+    }
+    /** @deprecated */
+    addModifier(flags: Es2pandaModifierFlags): this {
+        global.generatedEs2panda._ScriptFunctionAddModifier(global.context, this.peer, flags)
+        return this
+    }
+    get formalParamsLength(): number {
+        return global.generatedEs2panda._ScriptFunctionFormalParamsLengthConst(global.context, this.peer)
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._ScriptFunctionAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._ScriptFunctionSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isScriptFunction(node: object | undefined): node is ScriptFunction {
+    return node instanceof ScriptFunction
+}
+if (!nodeByType.has(59)) {
+    nodeByType.set(59, ScriptFunction)
+}

package/build/libarkts-copy/src/generated/peers/SequenceExpression.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 SequenceExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 60)
+        super(pointer)
+    }
+    static createSequenceExpression(sequence_arg: readonly Expression[]): SequenceExpression {
+        return new SequenceExpression(global.generatedEs2panda._CreateSequenceExpression(global.context, passNodeArray(sequence_arg), sequence_arg.length))
+    }
+    static updateSequenceExpression(original: SequenceExpression | undefined, sequence_arg: readonly Expression[]): SequenceExpression {
+        return new SequenceExpression(global.generatedEs2panda._UpdateSequenceExpression(global.context, passNode(original), passNodeArray(sequence_arg), sequence_arg.length))
+    }
+    get sequence(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._SequenceExpressionSequenceConst(global.context, this.peer))
+    }
+}
+export function isSequenceExpression(node: object | undefined): node is SequenceExpression {
+    return node instanceof SequenceExpression
+}
+if (!nodeByType.has(60)) {
+    nodeByType.set(60, SequenceExpression)
+}

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

@@ -0,0 +1,79 @@
+/*
+ * 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 SpreadElement extends AnnotatedExpression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 162)
+        super(pointer)
+    }
+    static createSpreadElement(nodeType: Es2pandaAstNodeType, argument?: Expression): SpreadElement {
+        return new SpreadElement(global.generatedEs2panda._CreateSpreadElement(global.context, nodeType, passNode(argument)))
+    }
+    static updateSpreadElement(original: SpreadElement | undefined, nodeType: Es2pandaAstNodeType, argument?: Expression): SpreadElement {
+        return new SpreadElement(global.generatedEs2panda._UpdateSpreadElement(global.context, passNode(original), nodeType, passNode(argument)))
+    }
+    get argument(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._SpreadElementArgumentConst(global.context, this.peer))
+    }
+    get isOptional(): boolean {
+        return global.generatedEs2panda._SpreadElementIsOptionalConst(global.context, this.peer)
+    }
+    get decorators(): readonly Decorator[] {
+        return unpackNodeArray(global.generatedEs2panda._SpreadElementDecoratorsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setOptional(optional_arg: boolean): this {
+        global.generatedEs2panda._SpreadElementSetOptional(global.context, this.peer, optional_arg)
+        return this
+    }
+    get validateExpression(): ValidationInfo | undefined {
+        return new ValidationInfo(global.generatedEs2panda._SpreadElementValidateExpression(global.context, this.peer))
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._SpreadElementTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTsTypeAnnotation(typeAnnotation?: TypeNode): this {
+        global.generatedEs2panda._SpreadElementSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
+        return this
+    }
+}
+export function isSpreadElement(node: object | undefined): node is SpreadElement {
+    return node instanceof SpreadElement
+}
+if (!nodeByType.has(162)) {
+    nodeByType.set(162, SpreadElement)
+}

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

@@ -0,0 +1,82 @@
+/*
+ * 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 SrcDumper extends ArktsObject {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+    static createSrcDumper(node?: AstNode): SrcDumper {
+        return new SrcDumper(global.generatedEs2panda._CreateSrcDumper(global.context, passNode(node)))
+    }
+    /** @deprecated */
+    add(str: string): this {
+        global.generatedEs2panda._SrcDumperAdd(global.context, this.peer, str)
+        return this
+    }
+    /** @deprecated */
+    add1(i: number): this {
+        global.generatedEs2panda._SrcDumperAdd1(global.context, this.peer, i)
+        return this
+    }
+    /** @deprecated */
+    add2(l: number): this {
+        global.generatedEs2panda._SrcDumperAdd2(global.context, this.peer, l)
+        return this
+    }
+    /** @deprecated */
+    add3(f: number): this {
+        global.generatedEs2panda._SrcDumperAdd3(global.context, this.peer, f)
+        return this
+    }
+    /** @deprecated */
+    add4(d: number): this {
+        global.generatedEs2panda._SrcDumperAdd4(global.context, this.peer, d)
+        return this
+    }
+    get str(): string {
+        return unpackString(global.generatedEs2panda._SrcDumperStrConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    incrIndent(): this {
+        global.generatedEs2panda._SrcDumperIncrIndent(global.context, this.peer)
+        return this
+    }
+    /** @deprecated */
+    decrIndent(): this {
+        global.generatedEs2panda._SrcDumperDecrIndent(global.context, this.peer)
+        return this
+    }
+    /** @deprecated */
+    endl(num: number): this {
+        global.generatedEs2panda._SrcDumperEndl(global.context, this.peer, num)
+        return this
+    }
+}

package/build/libarkts-copy/src/generated/peers/Statement.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 Statement extends AstNode {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}
+export function isStatement(node: object | undefined): node is Statement {
+    return node instanceof Statement
+}