@idlizer/arktscgen 2.1.2

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

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

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

@@ -0,0 +1,64 @@
+/*
+ * 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 ForOfStatement extends LoopStatement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 32)
+        super(pointer)
+    }
+    static createForOfStatement(left: AstNode | undefined, right: Expression | undefined, body: Statement | undefined, isAwait: boolean): ForOfStatement {
+        return new ForOfStatement(global.generatedEs2panda._CreateForOfStatement(global.context, passNode(left), passNode(right), passNode(body), isAwait))
+    }
+    static updateForOfStatement(original: ForOfStatement | undefined, left: AstNode | undefined, right: Expression | undefined, body: Statement | undefined, isAwait: boolean): ForOfStatement {
+        return new ForOfStatement(global.generatedEs2panda._UpdateForOfStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body), isAwait))
+    }
+    get left(): AstNode | undefined {
+        return unpackNode(global.generatedEs2panda._ForOfStatementLeftConst(global.context, this.peer))
+    }
+    get right(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ForOfStatementRightConst(global.context, this.peer))
+    }
+    get body(): Statement | undefined {
+        return unpackNode(global.generatedEs2panda._ForOfStatementBodyConst(global.context, this.peer))
+    }
+    get isAwait(): boolean {
+        return global.generatedEs2panda._ForOfStatementIsAwaitConst(global.context, this.peer)
+    }
+}
+export function isForOfStatement(node: object | undefined): node is ForOfStatement {
+    return node instanceof ForOfStatement
+}
+if (!nodeByType.has(32)) {
+    nodeByType.set(32, ForOfStatement)
+}

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

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

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

package/build/libarkts-copy/src/generated/peers/FunctionDeclaration.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 { AnnotationUsage } from "./AnnotationUsage"
+import { ScriptFunction } from "./ScriptFunction"
+import { Statement } from "./Statement"
+export class FunctionDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 34)
+        super(pointer)
+    }
+    static createFunctionDeclaration(func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration {
+        return new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration(global.context, passNode(func), passNodeArray(annotations), annotations.length, isAnonymous))
+    }
+    static updateFunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration {
+        return new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration(global.context, passNode(original), passNode(func), passNodeArray(annotations), annotations.length, isAnonymous))
+    }
+    static update1FunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration {
+        return new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration1(global.context, passNode(original), passNode(func), isAnonymous))
+    }
+    get isAnonymous(): boolean {
+        return global.generatedEs2panda._FunctionDeclarationIsAnonymousConst(global.context, this.peer)
+    }
+    get function(): ScriptFunction {
+        return unpackNonNullableNode(global.generatedEs2panda._FunctionDeclarationFunctionConst(global.context, this.peer))
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._FunctionDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isFunctionDeclaration(node: object | undefined): node is FunctionDeclaration {
+    return node instanceof FunctionDeclaration
+}
+if (!nodeByType.has(34)) {
+    nodeByType.set(34, FunctionDeclaration)
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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 { ScriptFunction } from "./ScriptFunction"
+export class FunctionExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 35)
+        super(pointer)
+    }
+    static create1FunctionExpression(namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression {
+        return new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression1(global.context, passNode(namedExpr), passNode(func)))
+    }
+    static updateFunctionExpression(original?: FunctionExpression, func?: ScriptFunction): FunctionExpression {
+        return new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression(global.context, passNode(original), passNode(func)))
+    }
+    static update1FunctionExpression(original?: FunctionExpression, namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression {
+        return new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression1(global.context, passNode(original), passNode(namedExpr), passNode(func)))
+    }
+    get function(): ScriptFunction | undefined {
+        return unpackNode(global.generatedEs2panda._FunctionExpressionFunctionConst(global.context, this.peer))
+    }
+    get isAnonymous(): boolean {
+        return global.generatedEs2panda._FunctionExpressionIsAnonymousConst(global.context, this.peer)
+    }
+    get id(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._FunctionExpressionId(global.context, this.peer))
+    }
+}
+export function isFunctionExpression(node: object | undefined): node is FunctionExpression {
+    return node instanceof FunctionExpression
+}
+if (!nodeByType.has(35)) {
+    nodeByType.set(35, FunctionExpression)
+}

package/build/libarkts-copy/src/generated/peers/FunctionSignature.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 { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
+import { TypeNode } from "./TypeNode"
+export class FunctionSignature extends ArktsObject {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+    static createFunctionSignature(typeParams: TSTypeParameterDeclaration | undefined, params: readonly Expression[], returnTypeAnnotation: TypeNode | undefined, hasReceiver: boolean): FunctionSignature {
+        return new FunctionSignature(global.generatedEs2panda._CreateFunctionSignature(global.context, passNode(typeParams), passNodeArray(params), params.length, passNode(returnTypeAnnotation), hasReceiver))
+    }
+    get params(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._FunctionSignatureParamsConst(global.context, this.peer))
+    }
+    get typeParams(): TSTypeParameterDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._FunctionSignatureTypeParamsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setReturnType(type?: TypeNode): this {
+        global.generatedEs2panda._FunctionSignatureSetReturnType(global.context, this.peer, passNode(type))
+        return this
+    }
+    get returnType(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._FunctionSignatureReturnTypeConst(global.context, this.peer))
+    }
+    get clone(): FunctionSignature | undefined {
+        return new FunctionSignature(global.generatedEs2panda._FunctionSignatureClone(global.context, this.peer))
+    }
+    get hasReceiver(): boolean {
+        return global.generatedEs2panda._FunctionSignatureHasReceiverConst(global.context, this.peer)
+    }
+}

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

@@ -0,0 +1,154 @@
+/*
+ * 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 { TypeNode } from "./TypeNode"
+import { ValidationInfo } from "./ValidationInfo"
+export class Identifier extends AnnotatedExpression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 36)
+        super(pointer)
+    }
+    static create2Identifier(name: string, typeAnnotation?: TypeNode): Identifier {
+        return new Identifier(global.generatedEs2panda._CreateIdentifier2(global.context, name, passNode(typeAnnotation)))
+    }
+    static updateIdentifier(original?: Identifier): Identifier {
+        return new Identifier(global.generatedEs2panda._UpdateIdentifier(global.context, passNode(original)))
+    }
+    static update1Identifier(original: Identifier | undefined, name: string): Identifier {
+        return new Identifier(global.generatedEs2panda._UpdateIdentifier1(global.context, passNode(original), name))
+    }
+    static update2Identifier(original: Identifier | undefined, name: string, typeAnnotation?: TypeNode): Identifier {
+        return new Identifier(global.generatedEs2panda._UpdateIdentifier2(global.context, passNode(original), name, passNode(typeAnnotation)))
+    }
+    get name(): string {
+        return unpackString(global.generatedEs2panda._IdentifierNameConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setName(newName: string): this {
+        global.generatedEs2panda._IdentifierSetName(global.context, this.peer, newName)
+        return this
+    }
+    get decorators(): readonly Decorator[] {
+        return unpackNodeArray(global.generatedEs2panda._IdentifierDecoratorsConst(global.context, this.peer))
+    }
+    get isErrorPlaceHolder(): boolean {
+        return global.generatedEs2panda._IdentifierIsErrorPlaceHolderConst(global.context, this.peer)
+    }
+    get isOptional(): boolean {
+        return global.generatedEs2panda._IdentifierIsOptionalConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setOptional(optional_arg: boolean): this {
+        global.generatedEs2panda._IdentifierSetOptional(global.context, this.peer, optional_arg)
+        return this
+    }
+    get isReference(): boolean {
+        return global.generatedEs2panda._IdentifierIsReferenceConst(global.context, this.peer)
+    }
+    get isTdz(): boolean {
+        return global.generatedEs2panda._IdentifierIsTdzConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setTdz(): this {
+        global.generatedEs2panda._IdentifierSetTdz(global.context, this.peer)
+        return this
+    }
+    /** @deprecated */
+    setAccessor(): this {
+        global.generatedEs2panda._IdentifierSetAccessor(global.context, this.peer)
+        return this
+    }
+    get isAccessor(): boolean {
+        return global.generatedEs2panda._IdentifierIsAccessorConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setMutator(): this {
+        global.generatedEs2panda._IdentifierSetMutator(global.context, this.peer)
+        return this
+    }
+    get isMutator(): boolean {
+        return global.generatedEs2panda._IdentifierIsMutatorConst(global.context, this.peer)
+    }
+    get isReceiver(): boolean {
+        return global.generatedEs2panda._IdentifierIsReceiverConst(global.context, this.peer)
+    }
+    get isPrivateIdent(): boolean {
+        return global.generatedEs2panda._IdentifierIsPrivateIdentConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setPrivate(isPrivate: boolean): this {
+        global.generatedEs2panda._IdentifierSetPrivate(global.context, this.peer, isPrivate)
+        return this
+    }
+    get isIgnoreBox(): boolean {
+        return global.generatedEs2panda._IdentifierIsIgnoreBoxConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setIgnoreBox(): this {
+        global.generatedEs2panda._IdentifierSetIgnoreBox(global.context, this.peer)
+        return this
+    }
+    get isAnnotationDecl(): boolean {
+        return global.generatedEs2panda._IdentifierIsAnnotationDeclConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setAnnotationDecl(): this {
+        global.generatedEs2panda._IdentifierSetAnnotationDecl(global.context, this.peer)
+        return this
+    }
+    get isAnnotationUsage(): boolean {
+        return global.generatedEs2panda._IdentifierIsAnnotationUsageConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setAnnotationUsage(): this {
+        global.generatedEs2panda._IdentifierSetAnnotationUsage(global.context, this.peer)
+        return this
+    }
+    get validateExpression(): ValidationInfo | undefined {
+        return new ValidationInfo(global.generatedEs2panda._IdentifierValidateExpression(global.context, this.peer))
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._IdentifierTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTsTypeAnnotation(typeAnnotation?: TypeNode): this {
+        global.generatedEs2panda._IdentifierSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
+        return this
+    }
+}
+export function isIdentifier(node: object | undefined): node is Identifier {
+    return node instanceof Identifier
+}
+if (!nodeByType.has(36)) {
+    nodeByType.set(36, Identifier)
+}

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

@@ -0,0 +1,65 @@
+/*
+ * 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 IfStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 38)
+        super(pointer)
+    }
+    static createIfStatement(test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement {
+        return new IfStatement(global.generatedEs2panda._CreateIfStatement(global.context, passNode(test), passNode(consequent), passNode(alternate)))
+    }
+    static updateIfStatement(original?: IfStatement, test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement {
+        return new IfStatement(global.generatedEs2panda._UpdateIfStatement(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)))
+    }
+    get test(): Expression {
+        return unpackNonNullableNode(global.generatedEs2panda._IfStatementTestConst(global.context, this.peer))
+    }
+    get consequent(): Statement {
+        return unpackNonNullableNode(global.generatedEs2panda._IfStatementConsequentConst(global.context, this.peer))
+    }
+    get alternate(): Statement | undefined {
+        return unpackNode(global.generatedEs2panda._IfStatementAlternateConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAlternate(alternate?: Statement): this {
+        global.generatedEs2panda._IfStatementSetAlternate(global.context, this.peer, passNode(alternate))
+        return this
+    }
+}
+export function isIfStatement(node: object | undefined): node is IfStatement {
+    return node instanceof IfStatement
+}
+if (!nodeByType.has(38)) {
+    nodeByType.set(38, IfStatement)
+}