@idlizer/arktscgen 2.1.2

package/build/libarkts-copy/src/generated/peers/MetaProperty.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 { Es2pandaMetaPropertyKind } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+export class MetaProperty extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 46)
+        super(pointer)
+    }
+    static createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty {
+        return new MetaProperty(global.generatedEs2panda._CreateMetaProperty(global.context, kind))
+    }
+    static updateMetaProperty(original: MetaProperty | undefined, kind: Es2pandaMetaPropertyKind): MetaProperty {
+        return new MetaProperty(global.generatedEs2panda._UpdateMetaProperty(global.context, passNode(original), kind))
+    }
+    get kind(): Es2pandaMetaPropertyKind {
+        return global.generatedEs2panda._MetaPropertyKindConst(global.context, this.peer)
+    }
+}
+export function isMetaProperty(node: object | undefined): node is MetaProperty {
+    return node instanceof MetaProperty
+}
+if (!nodeByType.has(46)) {
+    nodeByType.set(46, MetaProperty)
+}

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

@@ -0,0 +1,105 @@
+/*
+ * 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 { Es2pandaMethodDefinitionKind } from "./../Es2pandaEnums"
+import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { ScriptFunction } from "./ScriptFunction"
+export class MethodDefinition extends ClassElement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 47)
+        super(pointer)
+    }
+    static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition {
+        return new MethodDefinition(global.generatedEs2panda._CreateMethodDefinition(global.context, kind, passNode(key), passNode(value), modifiers, isComputed))
+    }
+    static updateMethodDefinition(original: MethodDefinition | undefined, kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean): MethodDefinition {
+        return new MethodDefinition(global.generatedEs2panda._UpdateMethodDefinition(global.context, passNode(original), kind, passNode(key), passNode(value), modifiers, isComputed))
+    }
+    get kind(): Es2pandaMethodDefinitionKind {
+        return global.generatedEs2panda._MethodDefinitionKindConst(global.context, this.peer)
+    }
+    get isConstructor(): boolean {
+        return global.generatedEs2panda._MethodDefinitionIsConstructorConst(global.context, this.peer)
+    }
+    get isExtensionMethod(): boolean {
+        return global.generatedEs2panda._MethodDefinitionIsExtensionMethodConst(global.context, this.peer)
+    }
+    get overloads(): readonly MethodDefinition[] {
+        return unpackNodeArray(global.generatedEs2panda._MethodDefinitionOverloadsConst(global.context, this.peer))
+    }
+    get baseOverloadMethod(): MethodDefinition | undefined {
+        return unpackNode(global.generatedEs2panda._MethodDefinitionBaseOverloadMethodConst(global.context, this.peer))
+    }
+    get asyncPairMethod(): MethodDefinition | undefined {
+        return unpackNode(global.generatedEs2panda._MethodDefinitionAsyncPairMethodConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setOverloads(overloads: readonly MethodDefinition[]): this {
+        global.generatedEs2panda._MethodDefinitionSetOverloads(global.context, this.peer, passNodeArray(overloads), overloads.length)
+        return this
+    }
+    /** @deprecated */
+    clearOverloads(): this {
+        global.generatedEs2panda._MethodDefinitionClearOverloads(global.context, this.peer)
+        return this
+    }
+    /** @deprecated */
+    addOverload(overload?: MethodDefinition): this {
+        global.generatedEs2panda._MethodDefinitionAddOverload(global.context, this.peer, passNode(overload))
+        return this
+    }
+    /** @deprecated */
+    setBaseOverloadMethod(baseOverloadMethod?: MethodDefinition): this {
+        global.generatedEs2panda._MethodDefinitionSetBaseOverloadMethod(global.context, this.peer, passNode(baseOverloadMethod))
+        return this
+    }
+    /** @deprecated */
+    setAsyncPairMethod(method?: MethodDefinition): this {
+        global.generatedEs2panda._MethodDefinitionSetAsyncPairMethod(global.context, this.peer, passNode(method))
+        return this
+    }
+    get function(): ScriptFunction {
+        return unpackNonNullableNode(global.generatedEs2panda._MethodDefinitionFunctionConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    initializeOverloadInfo(): this {
+        global.generatedEs2panda._MethodDefinitionInitializeOverloadInfo(global.context, this.peer)
+        return this
+    }
+}
+export function isMethodDefinition(node: object | undefined): node is MethodDefinition {
+    return node instanceof MethodDefinition
+}
+if (!nodeByType.has(47)) {
+    nodeByType.set(47, MethodDefinition)
+}

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

@@ -0,0 +1,76 @@
+/*
+ * 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 { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
+import { TypeNode } from "./TypeNode"
+export class NamedType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 48)
+        super(pointer)
+    }
+    static createNamedType(name?: Identifier): NamedType {
+        return new NamedType(global.generatedEs2panda._CreateNamedType(global.context, passNode(name)))
+    }
+    static updateNamedType(original?: NamedType, name?: Identifier): NamedType {
+        return new NamedType(global.generatedEs2panda._UpdateNamedType(global.context, passNode(original), passNode(name)))
+    }
+    get name(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._NamedTypeNameConst(global.context, this.peer))
+    }
+    get typeParams(): TSTypeParameterInstantiation | undefined {
+        return unpackNode(global.generatedEs2panda._NamedTypeTypeParamsConst(global.context, this.peer))
+    }
+    get isNullable(): boolean {
+        return global.generatedEs2panda._NamedTypeIsNullableConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setNullable(nullable: boolean): this {
+        global.generatedEs2panda._NamedTypeSetNullable(global.context, this.peer, nullable)
+        return this
+    }
+    /** @deprecated */
+    setNext(next?: NamedType): this {
+        global.generatedEs2panda._NamedTypeSetNext(global.context, this.peer, passNode(next))
+        return this
+    }
+    /** @deprecated */
+    setTypeParams(typeParams?: TSTypeParameterInstantiation): this {
+        global.generatedEs2panda._NamedTypeSetTypeParams(global.context, this.peer, passNode(typeParams))
+        return this
+    }
+}
+export function isNamedType(node: object | undefined): node is NamedType {
+    return node instanceof NamedType
+}
+if (!nodeByType.has(48)) {
+    nodeByType.set(48, NamedType)
+}

package/build/libarkts-copy/src/generated/peers/NewExpression.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 { Expression } from "./Expression"
+export class NewExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 49)
+        super(pointer)
+    }
+    static createNewExpression(callee: Expression | undefined, _arguments: readonly Expression[]): NewExpression {
+        return new NewExpression(global.generatedEs2panda._CreateNewExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length))
+    }
+    static updateNewExpression(original: NewExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[]): NewExpression {
+        return new NewExpression(global.generatedEs2panda._UpdateNewExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length))
+    }
+    get callee(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._NewExpressionCalleeConst(global.context, this.peer))
+    }
+    get arguments(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._NewExpressionArgumentsConst(global.context, this.peer))
+    }
+}
+export function isNewExpression(node: object | undefined): node is NewExpression {
+    return node instanceof NewExpression
+}
+if (!nodeByType.has(49)) {
+    nodeByType.set(49, NewExpression)
+}

package/build/libarkts-copy/src/generated/peers/NullLiteral.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 { Literal } from "./Literal"
+export class NullLiteral extends Literal {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 50)
+        super(pointer)
+    }
+    static createNullLiteral(): NullLiteral {
+        return new NullLiteral(global.generatedEs2panda._CreateNullLiteral(global.context))
+    }
+    static updateNullLiteral(original?: NullLiteral): NullLiteral {
+        return new NullLiteral(global.generatedEs2panda._UpdateNullLiteral(global.context, passNode(original)))
+    }
+}
+export function isNullLiteral(node: object | undefined): node is NullLiteral {
+    return node instanceof NullLiteral
+}
+if (!nodeByType.has(50)) {
+    nodeByType.set(50, NullLiteral)
+}

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

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

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

@@ -0,0 +1,90 @@
+/*
+ * 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 ObjectExpression extends AnnotatedExpression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 160)
+        super(pointer)
+    }
+    static createObjectExpression(nodeType: Es2pandaAstNodeType, properties: readonly Expression[], trailingComma: boolean): ObjectExpression {
+        return new ObjectExpression(global.generatedEs2panda._CreateObjectExpression(global.context, nodeType, passNodeArray(properties), properties.length, trailingComma))
+    }
+    static updateObjectExpression(original: ObjectExpression | undefined, nodeType: Es2pandaAstNodeType, properties: readonly Expression[], trailingComma: boolean): ObjectExpression {
+        return new ObjectExpression(global.generatedEs2panda._UpdateObjectExpression(global.context, passNode(original), nodeType, passNodeArray(properties), properties.length, trailingComma))
+    }
+    get properties(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._ObjectExpressionPropertiesConst(global.context, this.peer))
+    }
+    get isDeclaration(): boolean {
+        return global.generatedEs2panda._ObjectExpressionIsDeclarationConst(global.context, this.peer)
+    }
+    get isOptional(): boolean {
+        return global.generatedEs2panda._ObjectExpressionIsOptionalConst(global.context, this.peer)
+    }
+    get decorators(): readonly Decorator[] {
+        return unpackNodeArray(global.generatedEs2panda._ObjectExpressionDecoratorsConst(global.context, this.peer))
+    }
+    get validateExpression(): ValidationInfo | undefined {
+        return new ValidationInfo(global.generatedEs2panda._ObjectExpressionValidateExpression(global.context, this.peer))
+    }
+    get convertibleToObjectPattern(): boolean {
+        return global.generatedEs2panda._ObjectExpressionConvertibleToObjectPattern(global.context, this.peer)
+    }
+    /** @deprecated */
+    setDeclaration(): this {
+        global.generatedEs2panda._ObjectExpressionSetDeclaration(global.context, this.peer)
+        return this
+    }
+    /** @deprecated */
+    setOptional(optional_arg: boolean): this {
+        global.generatedEs2panda._ObjectExpressionSetOptional(global.context, this.peer, optional_arg)
+        return this
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._ObjectExpressionTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTsTypeAnnotation(typeAnnotation?: TypeNode): this {
+        global.generatedEs2panda._ObjectExpressionSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
+        return this
+    }
+}
+export function isObjectExpression(node: object | undefined): node is ObjectExpression {
+    return node instanceof ObjectExpression
+}
+if (!nodeByType.has(160)) {
+    nodeByType.set(160, ObjectExpression)
+}

package/build/libarkts-copy/src/generated/peers/OmittedExpression.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 { Expression } from "./Expression"
+export class OmittedExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 53)
+        super(pointer)
+    }
+    static createOmittedExpression(): OmittedExpression {
+        return new OmittedExpression(global.generatedEs2panda._CreateOmittedExpression(global.context))
+    }
+    static updateOmittedExpression(original?: OmittedExpression): OmittedExpression {
+        return new OmittedExpression(global.generatedEs2panda._UpdateOmittedExpression(global.context, passNode(original)))
+    }
+}
+export function isOmittedExpression(node: object | undefined): node is OmittedExpression {
+    return node instanceof OmittedExpression
+}
+if (!nodeByType.has(53)) {
+    nodeByType.set(53, OmittedExpression)
+}

package/build/libarkts-copy/src/generated/peers/OpaqueTypeNode.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 OpaqueTypeNode extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 153)
+        super(pointer)
+    }
+    static create1OpaqueTypeNode(): OpaqueTypeNode {
+        return new OpaqueTypeNode(global.generatedEs2panda._CreateOpaqueTypeNode1(global.context))
+    }
+    static update1OpaqueTypeNode(original?: OpaqueTypeNode): OpaqueTypeNode {
+        return new OpaqueTypeNode(global.generatedEs2panda._UpdateOpaqueTypeNode1(global.context, passNode(original)))
+    }
+}
+export function isOpaqueTypeNode(node: object | undefined): node is OpaqueTypeNode {
+    return node instanceof OpaqueTypeNode
+}
+if (!nodeByType.has(153)) {
+    nodeByType.set(153, OpaqueTypeNode)
+}

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

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