@idlizer/arktscgen 2.1.2

package/build/libarkts-copy/src/generated/peers/ImportDeclaration.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 { Es2pandaImportKinds } from "./../Es2pandaEnums"
+import { Statement } from "./Statement"
+import { StringLiteral } from "./StringLiteral"
+export class ImportDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 39)
+        super(pointer)
+    }
+    static createImportDeclaration(source: StringLiteral | undefined, specifiers: readonly AstNode[], importKind: Es2pandaImportKinds): ImportDeclaration {
+        return new ImportDeclaration(global.generatedEs2panda._CreateImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length, importKind))
+    }
+    static updateImportDeclaration(original: ImportDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly AstNode[], importKind: Es2pandaImportKinds): ImportDeclaration {
+        return new ImportDeclaration(global.generatedEs2panda._UpdateImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length, importKind))
+    }
+    get source(): StringLiteral | undefined {
+        return unpackNode(global.generatedEs2panda._ImportDeclarationSourceConst(global.context, this.peer))
+    }
+    get specifiers(): readonly AstNode[] {
+        return unpackNodeArray(global.generatedEs2panda._ImportDeclarationSpecifiersConst(global.context, this.peer))
+    }
+    get isTypeKind(): boolean {
+        return global.generatedEs2panda._ImportDeclarationIsTypeKindConst(global.context, this.peer)
+    }
+}
+export function isImportDeclaration(node: object | undefined): node is ImportDeclaration {
+    return node instanceof ImportDeclaration
+}
+if (!nodeByType.has(39)) {
+    nodeByType.set(39, ImportDeclaration)
+}

package/build/libarkts-copy/src/generated/peers/ImportDefaultSpecifier.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 { Identifier } from "./Identifier"
+import { Statement } from "./Statement"
+export class ImportDefaultSpecifier extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 41)
+        super(pointer)
+    }
+    static createImportDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier {
+        return new ImportDefaultSpecifier(global.generatedEs2panda._CreateImportDefaultSpecifier(global.context, passNode(local)))
+    }
+    static updateImportDefaultSpecifier(original?: ImportDefaultSpecifier, local?: Identifier): ImportDefaultSpecifier {
+        return new ImportDefaultSpecifier(global.generatedEs2panda._UpdateImportDefaultSpecifier(global.context, passNode(original), passNode(local)))
+    }
+    get local(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ImportDefaultSpecifierLocalConst(global.context, this.peer))
+    }
+}
+export function isImportDefaultSpecifier(node: object | undefined): node is ImportDefaultSpecifier {
+    return node instanceof ImportDefaultSpecifier
+}
+if (!nodeByType.has(41)) {
+    nodeByType.set(41, ImportDefaultSpecifier)
+}

package/build/libarkts-copy/src/generated/peers/ImportExpression.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 ImportExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 40)
+        super(pointer)
+    }
+    static createImportExpression(source?: Expression): ImportExpression {
+        return new ImportExpression(global.generatedEs2panda._CreateImportExpression(global.context, passNode(source)))
+    }
+    static updateImportExpression(original?: ImportExpression, source?: Expression): ImportExpression {
+        return new ImportExpression(global.generatedEs2panda._UpdateImportExpression(global.context, passNode(original), passNode(source)))
+    }
+    get source(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ImportExpressionSourceConst(global.context, this.peer))
+    }
+}
+export function isImportExpression(node: object | undefined): node is ImportExpression {
+    return node instanceof ImportExpression
+}
+if (!nodeByType.has(40)) {
+    nodeByType.set(40, ImportExpression)
+}

package/build/libarkts-copy/src/generated/peers/ImportNamespaceSpecifier.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 { Identifier } from "./Identifier"
+import { Statement } from "./Statement"
+export class ImportNamespaceSpecifier extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 42)
+        super(pointer)
+    }
+    static createImportNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier {
+        return new ImportNamespaceSpecifier(global.generatedEs2panda._CreateImportNamespaceSpecifier(global.context, passNode(local)))
+    }
+    static updateImportNamespaceSpecifier(original?: ImportNamespaceSpecifier, local?: Identifier): ImportNamespaceSpecifier {
+        return new ImportNamespaceSpecifier(global.generatedEs2panda._UpdateImportNamespaceSpecifier(global.context, passNode(original), passNode(local)))
+    }
+    get local(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._ImportNamespaceSpecifierLocalConst(global.context, this.peer))
+    }
+}
+export function isImportNamespaceSpecifier(node: object | undefined): node is ImportNamespaceSpecifier {
+    return node instanceof ImportNamespaceSpecifier
+}
+if (!nodeByType.has(42)) {
+    nodeByType.set(42, ImportNamespaceSpecifier)
+}

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

@@ -0,0 +1,49 @@
+/*
+ * 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 { StringLiteral } from "./StringLiteral"
+export class ImportSource extends ArktsObject {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+    static createImportSource(source: StringLiteral | undefined, resolvedSource: StringLiteral | undefined, hasDecl: boolean): ImportSource {
+        return new ImportSource(global.generatedEs2panda._CreateImportSource(global.context, passNode(source), passNode(resolvedSource), hasDecl))
+    }
+    get source(): StringLiteral | undefined {
+        return unpackNode(global.generatedEs2panda._ImportSourceSourceConst(global.context, this.peer))
+    }
+    get resolvedSource(): StringLiteral | undefined {
+        return unpackNode(global.generatedEs2panda._ImportSourceResolvedSourceConst(global.context, this.peer))
+    }
+    get hasDecl(): boolean {
+        return global.generatedEs2panda._ImportSourceHasDeclConst(global.context, this.peer)
+    }
+}

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

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

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

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

@@ -0,0 +1,60 @@
+/*
+ * 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 LabelledStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 44)
+        super(pointer)
+    }
+    static createLabelledStatement(ident?: Identifier, body?: Statement): LabelledStatement {
+        return new LabelledStatement(global.generatedEs2panda._CreateLabelledStatement(global.context, passNode(ident), passNode(body)))
+    }
+    static updateLabelledStatement(original?: LabelledStatement, ident?: Identifier, body?: Statement): LabelledStatement {
+        return new LabelledStatement(global.generatedEs2panda._UpdateLabelledStatement(global.context, passNode(original), passNode(ident), passNode(body)))
+    }
+    get body(): Statement | undefined {
+        return unpackNode(global.generatedEs2panda._LabelledStatementBodyConst(global.context, this.peer))
+    }
+    get ident(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._LabelledStatementIdentConst(global.context, this.peer))
+    }
+    get referencedStatement(): AstNode | undefined {
+        return unpackNode(global.generatedEs2panda._LabelledStatementGetReferencedStatementConst(global.context, this.peer))
+    }
+}
+export function isLabelledStatement(node: object | undefined): node is LabelledStatement {
+    return node instanceof LabelledStatement
+}
+if (!nodeByType.has(44)) {
+    nodeByType.set(44, LabelledStatement)
+}

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

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

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

@@ -0,0 +1,48 @@
+/*
+ * 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 MaybeOptionalExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+    get isOptional(): boolean {
+        return global.generatedEs2panda._MaybeOptionalExpressionIsOptionalConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    clearOptional(): this {
+        global.generatedEs2panda._MaybeOptionalExpressionClearOptional(global.context, this.peer)
+        return this
+    }
+}
+export function isMaybeOptionalExpression(node: object | undefined): node is MaybeOptionalExpression {
+    return node instanceof MaybeOptionalExpression
+}

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

@@ -0,0 +1,95 @@
+/*
+ * 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 { Es2pandaMemberExpressionKind } from "./../Es2pandaEnums"
+import { Expression } from "./Expression"
+import { MaybeOptionalExpression } from "./MaybeOptionalExpression"
+export class MemberExpression extends MaybeOptionalExpression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 45)
+        super(pointer)
+    }
+    static createMemberExpression(object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression {
+        return new MemberExpression(global.generatedEs2panda._CreateMemberExpression(global.context, passNode(object_arg), passNode(property), kind, computed, optional_arg))
+    }
+    static updateMemberExpression(original: MemberExpression | undefined, object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression {
+        return new MemberExpression(global.generatedEs2panda._UpdateMemberExpression(global.context, passNode(original), passNode(object_arg), passNode(property), kind, computed, optional_arg))
+    }
+    get object(): Expression {
+        return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionObjectConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setObject(object_arg?: Expression): this {
+        global.generatedEs2panda._MemberExpressionSetObject(global.context, this.peer, passNode(object_arg))
+        return this
+    }
+    /** @deprecated */
+    setProperty(prop?: Expression): this {
+        global.generatedEs2panda._MemberExpressionSetProperty(global.context, this.peer, passNode(prop))
+        return this
+    }
+    get property(): Expression {
+        return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionPropertyConst(global.context, this.peer))
+    }
+    get isComputed(): boolean {
+        return global.generatedEs2panda._MemberExpressionIsComputedConst(global.context, this.peer)
+    }
+    get kind(): Es2pandaMemberExpressionKind {
+        return global.generatedEs2panda._MemberExpressionKindConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    addMemberKind(kind: Es2pandaMemberExpressionKind): this {
+        global.generatedEs2panda._MemberExpressionAddMemberKind(global.context, this.peer, kind)
+        return this
+    }
+    /** @deprecated */
+    removeMemberKind(kind: Es2pandaMemberExpressionKind): this {
+        global.generatedEs2panda._MemberExpressionRemoveMemberKind(global.context, this.peer, kind)
+        return this
+    }
+    get isIgnoreBox(): boolean {
+        return global.generatedEs2panda._MemberExpressionIsIgnoreBoxConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setIgnoreBox(): this {
+        global.generatedEs2panda._MemberExpressionSetIgnoreBox(global.context, this.peer)
+        return this
+    }
+    get isPrivateReference(): boolean {
+        return global.generatedEs2panda._MemberExpressionIsPrivateReferenceConst(global.context, this.peer)
+    }
+}
+export function isMemberExpression(node: object | undefined): node is MemberExpression {
+    return node instanceof MemberExpression
+}
+if (!nodeByType.has(45)) {
+    nodeByType.set(45, MemberExpression)
+}