@idlizer/arktscgen 2.1.2

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

@@ -0,0 +1,233 @@
+/*
+ * 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 { ClassDeclaration } from "./ClassDeclaration"
+import { Es2pandaClassDefinitionModifiers } from "./../Es2pandaEnums"
+import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { FunctionExpression } from "./FunctionExpression"
+import { Identifier } from "./Identifier"
+import { MethodDefinition } from "./MethodDefinition"
+import { TSClassImplements } from "./TSClassImplements"
+import { TSEnumDeclaration } from "./TSEnumDeclaration"
+import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
+import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
+import { TypedAstNode } from "./TypedAstNode"
+export class ClassDefinition extends TypedAstNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 14)
+        super(pointer)
+    }
+    static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition {
+        return new ClassDefinition(global.generatedEs2panda._CreateClassDefinition(global.context, passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags))
+    }
+    static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition {
+        return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition(global.context, passNode(original), passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags))
+    }
+    static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition {
+        return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition1(global.context, passNode(original), passNode(ident), passNodeArray(body), body.length, modifiers, flags))
+    }
+    static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags): ClassDefinition {
+        return new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition2(global.context, passNode(original), passNode(ident), modifiers, flags))
+    }
+    get ident(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ClassDefinitionIdentConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setIdent(ident?: Identifier): this {
+        global.generatedEs2panda._ClassDefinitionSetIdent(global.context, this.peer, passNode(ident))
+        return this
+    }
+    get internalName(): string {
+        return unpackString(global.generatedEs2panda._ClassDefinitionInternalNameConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setInternalName(internalName: string): this {
+        global.generatedEs2panda._ClassDefinitionSetInternalName(global.context, this.peer, internalName)
+        return this
+    }
+    get super(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ClassDefinitionSuperConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setSuper(superClass?: Expression): this {
+        global.generatedEs2panda._ClassDefinitionSetSuper(global.context, this.peer, passNode(superClass))
+        return this
+    }
+    get isGlobal(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsGlobalConst(global.context, this.peer)
+    }
+    get isLocal(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsLocalConst(global.context, this.peer)
+    }
+    get isExtern(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsExternConst(global.context, this.peer)
+    }
+    get isFromExternal(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsFromExternalConst(global.context, this.peer)
+    }
+    get isInner(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsInnerConst(global.context, this.peer)
+    }
+    get isGlobalInitialized(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsGlobalInitializedConst(global.context, this.peer)
+    }
+    get isClassDefinitionChecked(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsClassDefinitionCheckedConst(global.context, this.peer)
+    }
+    get isAnonymous(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsAnonymousConst(global.context, this.peer)
+    }
+    get isIntEnumTransformed(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsIntEnumTransformedConst(global.context, this.peer)
+    }
+    get isStringEnumTransformed(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsStringEnumTransformedConst(global.context, this.peer)
+    }
+    get isEnumTransformed(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsEnumTransformedConst(global.context, this.peer)
+    }
+    get isNamespaceTransformed(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsNamespaceTransformedConst(global.context, this.peer)
+    }
+    get isModule(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsModuleConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setGlobalInitialized(): this {
+        global.generatedEs2panda._ClassDefinitionSetGlobalInitialized(global.context, this.peer)
+        return this
+    }
+    /** @deprecated */
+    setInnerModifier(): this {
+        global.generatedEs2panda._ClassDefinitionSetInnerModifier(global.context, this.peer)
+        return this
+    }
+    /** @deprecated */
+    setClassDefinitionChecked(): this {
+        global.generatedEs2panda._ClassDefinitionSetClassDefinitionChecked(global.context, this.peer)
+        return this
+    }
+    /** @deprecated */
+    setAnonymousModifier(): this {
+        global.generatedEs2panda._ClassDefinitionSetAnonymousModifier(global.context, this.peer)
+        return this
+    }
+    /** @deprecated */
+    setNamespaceTransformed(): this {
+        global.generatedEs2panda._ClassDefinitionSetNamespaceTransformed(global.context, this.peer)
+        return this
+    }
+    get modifiers(): Es2pandaClassDefinitionModifiers {
+        return global.generatedEs2panda._ClassDefinitionModifiersConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setModifiers(modifiers: Es2pandaClassDefinitionModifiers): this {
+        global.generatedEs2panda._ClassDefinitionSetModifiers(global.context, this.peer, modifiers)
+        return this
+    }
+    /** @deprecated */
+    addProperties(body: readonly AstNode[]): this {
+        global.generatedEs2panda._ClassDefinitionAddProperties(global.context, this.peer, passNodeArray(body), body.length)
+        return this
+    }
+    get body(): readonly AstNode[] {
+        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionBodyConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setCtor(ctor?: MethodDefinition): this {
+        global.generatedEs2panda._ClassDefinitionSetCtor(global.context, this.peer, passNode(ctor))
+        return this
+    }
+    get implements(): readonly TSClassImplements[] {
+        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionImplementsConst(global.context, this.peer))
+    }
+    get typeParams(): TSTypeParameterDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._ClassDefinitionTypeParamsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTypeParams(typeParams?: TSTypeParameterDeclaration): this {
+        global.generatedEs2panda._ClassDefinitionSetTypeParams(global.context, this.peer, passNode(typeParams))
+        return this
+    }
+    get superTypeParams(): TSTypeParameterInstantiation | undefined {
+        return unpackNode(global.generatedEs2panda._ClassDefinitionSuperTypeParamsConst(global.context, this.peer))
+    }
+    get localTypeCounter(): number {
+        return global.generatedEs2panda._ClassDefinitionLocalTypeCounter(global.context, this.peer)
+    }
+    get localIndex(): number {
+        return global.generatedEs2panda._ClassDefinitionLocalIndexConst(global.context, this.peer)
+    }
+    get localPrefix(): string {
+        return unpackString(global.generatedEs2panda._ClassDefinitionLocalPrefixConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setOrigEnumDecl(enumDecl?: TSEnumDeclaration): this {
+        global.generatedEs2panda._ClassDefinitionSetOrigEnumDecl(global.context, this.peer, passNode(enumDecl))
+        return this
+    }
+    get origEnumDecl(): TSEnumDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._ClassDefinitionOrigEnumDeclConst(global.context, this.peer))
+    }
+    get anonClass(): ClassDeclaration | undefined {
+        return unpackNode(global.generatedEs2panda._ClassDefinitionGetAnonClass(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnonClass(anonClass?: ClassDeclaration): this {
+        global.generatedEs2panda._ClassDefinitionSetAnonClass(global.context, this.peer, passNode(anonClass))
+        return this
+    }
+    get ctor(): FunctionExpression | undefined {
+        return unpackNode(global.generatedEs2panda._ClassDefinitionCtorConst(global.context, this.peer))
+    }
+    get hasPrivateMethod(): boolean {
+        return global.generatedEs2panda._ClassDefinitionHasPrivateMethodConst(global.context, this.peer)
+    }
+    get hasComputedInstanceField(): boolean {
+        return global.generatedEs2panda._ClassDefinitionHasComputedInstanceFieldConst(global.context, this.peer)
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._ClassDefinitionSetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isClassDefinition(node: object | undefined): node is ClassDefinition {
+    return node instanceof ClassDefinition
+}
+if (!nodeByType.has(14)) {
+    nodeByType.set(14, ClassDefinition)
+}

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

@@ -0,0 +1,80 @@
+/*
+ * 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 { Decorator } from "./Decorator"
+import { Expression } from "./Expression"
+import { Identifier } from "./Identifier"
+import { TSEnumMember } from "./TSEnumMember"
+import { TypedStatement } from "./TypedStatement"
+export class ClassElement extends TypedStatement {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+    get id(): Identifier {
+        return unpackNonNullableNode(global.generatedEs2panda._ClassElementIdConst(global.context, this.peer))
+    }
+    get key(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ClassElementKeyConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setValue(value?: Expression): this {
+        global.generatedEs2panda._ClassElementSetValue(global.context, this.peer, passNode(value))
+        return this
+    }
+    get value(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ClassElementValueConst(global.context, this.peer))
+    }
+    get originEnumMember(): TSEnumMember | undefined {
+        return unpackNode(global.generatedEs2panda._ClassElementOriginEnumMemberConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setOrigEnumMember(enumMember?: TSEnumMember): this {
+        global.generatedEs2panda._ClassElementSetOrigEnumMember(global.context, this.peer, passNode(enumMember))
+        return this
+    }
+    get isPrivateElement(): boolean {
+        return global.generatedEs2panda._ClassElementIsPrivateElementConst(global.context, this.peer)
+    }
+    get decorators(): readonly Decorator[] {
+        return unpackNodeArray(global.generatedEs2panda._ClassElementDecoratorsConst(global.context, this.peer))
+    }
+    get isComputed(): boolean {
+        return global.generatedEs2panda._ClassElementIsComputedConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    addDecorator(decorator?: Decorator): this {
+        global.generatedEs2panda._ClassElementAddDecorator(global.context, this.peer, passNode(decorator))
+        return this
+    }
+}
+export function isClassElement(node: object | undefined): node is ClassElement {
+    return node instanceof ClassElement
+}

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

@@ -0,0 +1,54 @@
+/*
+ * 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 { ClassDefinition } from "./ClassDefinition"
+import { Expression } from "./Expression"
+export class ClassExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 16)
+        super(pointer)
+    }
+    static createClassExpression(def?: ClassDefinition): ClassExpression {
+        return new ClassExpression(global.generatedEs2panda._CreateClassExpression(global.context, passNode(def)))
+    }
+    static updateClassExpression(original?: ClassExpression, def?: ClassDefinition): ClassExpression {
+        return new ClassExpression(global.generatedEs2panda._UpdateClassExpression(global.context, passNode(original), passNode(def)))
+    }
+    get definition(): ClassDefinition | undefined {
+        return unpackNode(global.generatedEs2panda._ClassExpressionDefinitionConst(global.context, this.peer))
+    }
+}
+export function isClassExpression(node: object | undefined): node is ClassExpression {
+    return node instanceof ClassExpression
+}
+if (!nodeByType.has(16)) {
+    nodeByType.set(16, ClassExpression)
+}

package/build/libarkts-copy/src/generated/peers/ClassProperty.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 { ClassElement } from "./ClassElement"
+import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { TypeNode } from "./TypeNode"
+export class ClassProperty extends ClassElement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 17)
+        super(pointer)
+    }
+    static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty {
+        return new ClassProperty(global.generatedEs2panda._CreateClassProperty(global.context, passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed))
+    }
+    static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): ClassProperty {
+        return new ClassProperty(global.generatedEs2panda._UpdateClassProperty(global.context, passNode(original), passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed))
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ClassPropertyTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTypeAnnotation(typeAnnotation?: TypeNode): this {
+        global.generatedEs2panda._ClassPropertySetTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
+        return this
+    }
+    get annotations(): readonly AnnotationUsage[] {
+        return unpackNodeArray(global.generatedEs2panda._ClassPropertyAnnotationsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAnnotations(annotations: readonly AnnotationUsage[]): this {
+        global.generatedEs2panda._ClassPropertySetAnnotations(global.context, this.peer, passNodeArray(annotations), annotations.length)
+        return this
+    }
+}
+export function isClassProperty(node: object | undefined): node is ClassProperty {
+    return node instanceof ClassProperty
+}
+if (!nodeByType.has(17)) {
+    nodeByType.set(17, ClassProperty)
+}

package/build/libarkts-copy/src/generated/peers/ClassStaticBlock.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 { ClassElement } from "./ClassElement"
+import { Expression } from "./Expression"
+import { ScriptFunction } from "./ScriptFunction"
+export class ClassStaticBlock extends ClassElement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 18)
+        super(pointer)
+    }
+    static createClassStaticBlock(value?: Expression): ClassStaticBlock {
+        return new ClassStaticBlock(global.generatedEs2panda._CreateClassStaticBlock(global.context, passNode(value)))
+    }
+    static updateClassStaticBlock(original?: ClassStaticBlock, value?: Expression): ClassStaticBlock {
+        return new ClassStaticBlock(global.generatedEs2panda._UpdateClassStaticBlock(global.context, passNode(original), passNode(value)))
+    }
+    get function(): ScriptFunction | undefined {
+        return unpackNode(global.generatedEs2panda._ClassStaticBlockFunctionConst(global.context, this.peer))
+    }
+    get name(): string {
+        return unpackString(global.generatedEs2panda._ClassStaticBlockNameConst(global.context, this.peer))
+    }
+}
+export function isClassStaticBlock(node: object | undefined): node is ClassStaticBlock {
+    return node instanceof ClassStaticBlock
+}
+if (!nodeByType.has(18)) {
+    nodeByType.set(18, ClassStaticBlock)
+}

package/build/libarkts-copy/src/generated/peers/ConditionalExpression.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"
+export class ConditionalExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 19)
+        super(pointer)
+    }
+    static createConditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression {
+        return new ConditionalExpression(global.generatedEs2panda._CreateConditionalExpression(global.context, passNode(test), passNode(consequent), passNode(alternate)))
+    }
+    static updateConditionalExpression(original?: ConditionalExpression, test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression {
+        return new ConditionalExpression(global.generatedEs2panda._UpdateConditionalExpression(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)))
+    }
+    get test(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ConditionalExpressionTestConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTest(expr?: Expression): this {
+        global.generatedEs2panda._ConditionalExpressionSetTest(global.context, this.peer, passNode(expr))
+        return this
+    }
+    get consequent(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ConditionalExpressionConsequentConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setConsequent(expr?: Expression): this {
+        global.generatedEs2panda._ConditionalExpressionSetConsequent(global.context, this.peer, passNode(expr))
+        return this
+    }
+    get alternate(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ConditionalExpressionAlternateConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setAlternate(expr?: Expression): this {
+        global.generatedEs2panda._ConditionalExpressionSetAlternate(global.context, this.peer, passNode(expr))
+        return this
+    }
+}
+export function isConditionalExpression(node: object | undefined): node is ConditionalExpression {
+    return node instanceof ConditionalExpression
+}
+if (!nodeByType.has(19)) {
+    nodeByType.set(19, ConditionalExpression)
+}

package/build/libarkts-copy/src/generated/peers/ContinueStatement.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 { Identifier } from "./Identifier"
+import { Statement } from "./Statement"
+export class ContinueStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 20)
+        super(pointer)
+    }
+    static create1ContinueStatement(ident?: Identifier): ContinueStatement {
+        return new ContinueStatement(global.generatedEs2panda._CreateContinueStatement1(global.context, passNode(ident)))
+    }
+    static updateContinueStatement(original?: ContinueStatement): ContinueStatement {
+        return new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement(global.context, passNode(original)))
+    }
+    static update1ContinueStatement(original?: ContinueStatement, ident?: Identifier): ContinueStatement {
+        return new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement1(global.context, passNode(original), passNode(ident)))
+    }
+    get ident(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ContinueStatementIdentConst(global.context, this.peer))
+    }
+    get target(): AstNode | undefined {
+        return unpackNode(global.generatedEs2panda._ContinueStatementTargetConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTarget(target?: AstNode): this {
+        global.generatedEs2panda._ContinueStatementSetTarget(global.context, this.peer, passNode(target))
+        return this
+    }
+}
+export function isContinueStatement(node: object | undefined): node is ContinueStatement {
+    return node instanceof ContinueStatement
+}
+if (!nodeByType.has(20)) {
+    nodeByType.set(20, ContinueStatement)
+}