@idlizer/arktscgen 2.1.2

package/build/libarkts-copy/src/generated/peers/BlockExpression.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 { Statement } from "./Statement"
+export class BlockExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 154)
+        super(pointer)
+    }
+    static createBlockExpression(statements: readonly Statement[]): BlockExpression {
+        return new BlockExpression(global.generatedEs2panda._CreateBlockExpression(global.context, passNodeArray(statements), statements.length))
+    }
+    static updateBlockExpression(original: BlockExpression | undefined, statements: readonly Statement[]): BlockExpression {
+        return new BlockExpression(global.generatedEs2panda._UpdateBlockExpression(global.context, passNode(original), passNodeArray(statements), statements.length))
+    }
+    get statements(): readonly Statement[] {
+        return unpackNodeArray(global.generatedEs2panda._BlockExpressionStatementsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    addStatements(statements: readonly Statement[]): this {
+        global.generatedEs2panda._BlockExpressionAddStatements(global.context, this.peer, passNodeArray(statements), statements.length)
+        return this
+    }
+    /** @deprecated */
+    addStatement(statement?: Statement): this {
+        global.generatedEs2panda._BlockExpressionAddStatement(global.context, this.peer, passNode(statement))
+        return this
+    }
+}
+export function isBlockExpression(node: object | undefined): node is BlockExpression {
+    return node instanceof BlockExpression
+}
+if (!nodeByType.has(154)) {
+    nodeByType.set(154, BlockExpression)
+}

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

@@ -0,0 +1,63 @@
+/*
+ * 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 BlockStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 7)
+        super(pointer)
+    }
+    static createBlockStatement(statementList: readonly Statement[]): BlockStatement {
+        return new BlockStatement(global.generatedEs2panda._CreateBlockStatement(global.context, passNodeArray(statementList), statementList.length))
+    }
+    static updateBlockStatement(original: BlockStatement | undefined, statementList: readonly Statement[]): BlockStatement {
+        return new BlockStatement(global.generatedEs2panda._UpdateBlockStatement(global.context, passNode(original), passNodeArray(statementList), statementList.length))
+    }
+    get statements(): readonly Statement[] {
+        return unpackNodeArray(global.generatedEs2panda._BlockStatementStatementsConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setStatements(statementList: readonly Statement[]): this {
+        global.generatedEs2panda._BlockStatementSetStatements(global.context, this.peer, passNodeArray(statementList), statementList.length)
+        return this
+    }
+    /** @deprecated */
+    addTrailingBlock(stmt?: AstNode, trailingBlock?: BlockStatement): this {
+        global.generatedEs2panda._BlockStatementAddTrailingBlock(global.context, this.peer, passNode(stmt), passNode(trailingBlock))
+        return this
+    }
+}
+export function isBlockStatement(node: object | undefined): node is BlockStatement {
+    return node instanceof BlockStatement
+}
+if (!nodeByType.has(7)) {
+    nodeByType.set(7, BlockStatement)
+}

package/build/libarkts-copy/src/generated/peers/BooleanLiteral.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 { Literal } from "./Literal"
+export class BooleanLiteral extends Literal {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 8)
+        super(pointer)
+    }
+    static createBooleanLiteral(value: boolean): BooleanLiteral {
+        return new BooleanLiteral(global.generatedEs2panda._CreateBooleanLiteral(global.context, value))
+    }
+    static updateBooleanLiteral(original: BooleanLiteral | undefined, value: boolean): BooleanLiteral {
+        return new BooleanLiteral(global.generatedEs2panda._UpdateBooleanLiteral(global.context, passNode(original), value))
+    }
+    get value(): boolean {
+        return global.generatedEs2panda._BooleanLiteralValueConst(global.context, this.peer)
+    }
+}
+export function isBooleanLiteral(node: object | undefined): node is BooleanLiteral {
+    return node instanceof BooleanLiteral
+}
+if (!nodeByType.has(8)) {
+    nodeByType.set(8, BooleanLiteral)
+}

package/build/libarkts-copy/src/generated/peers/BreakStatement.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 BreakStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 9)
+        super(pointer)
+    }
+    static create1BreakStatement(ident?: Identifier): BreakStatement {
+        return new BreakStatement(global.generatedEs2panda._CreateBreakStatement1(global.context, passNode(ident)))
+    }
+    static updateBreakStatement(original?: BreakStatement): BreakStatement {
+        return new BreakStatement(global.generatedEs2panda._UpdateBreakStatement(global.context, passNode(original)))
+    }
+    static update1BreakStatement(original?: BreakStatement, ident?: Identifier): BreakStatement {
+        return new BreakStatement(global.generatedEs2panda._UpdateBreakStatement1(global.context, passNode(original), passNode(ident)))
+    }
+    get ident(): Identifier | undefined {
+        return unpackNode(global.generatedEs2panda._BreakStatementIdentConst(global.context, this.peer))
+    }
+    get target(): AstNode | undefined {
+        return unpackNode(global.generatedEs2panda._BreakStatementTargetConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTarget(target?: AstNode): this {
+        global.generatedEs2panda._BreakStatementSetTarget(global.context, this.peer, passNode(target))
+        return this
+    }
+}
+export function isBreakStatement(node: object | undefined): node is BreakStatement {
+    return node instanceof BreakStatement
+}
+if (!nodeByType.has(9)) {
+    nodeByType.set(9, BreakStatement)
+}

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

@@ -0,0 +1,97 @@
+/*
+ * 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 { BlockStatement } from "./BlockStatement"
+import { Expression } from "./Expression"
+import { MaybeOptionalExpression } from "./MaybeOptionalExpression"
+import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
+export class CallExpression extends MaybeOptionalExpression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 10)
+        super(pointer)
+    }
+    static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean): CallExpression {
+        return new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, trailingComma))
+    }
+    static update1CallExpression(original?: CallExpression, other?: CallExpression): CallExpression {
+        return new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other)))
+    }
+    get callee(): Expression {
+        return unpackNonNullableNode(global.generatedEs2panda._CallExpressionCalleeConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setCallee(callee?: Expression): this {
+        global.generatedEs2panda._CallExpressionSetCallee(global.context, this.peer, passNode(callee))
+        return this
+    }
+    get typeParams(): TSTypeParameterInstantiation | undefined {
+        return unpackNode(global.generatedEs2panda._CallExpressionTypeParamsConst(global.context, this.peer))
+    }
+    get arguments(): readonly Expression[] {
+        return unpackNodeArray(global.generatedEs2panda._CallExpressionArgumentsConst(global.context, this.peer))
+    }
+    get hasTrailingComma(): boolean {
+        return global.generatedEs2panda._CallExpressionHasTrailingCommaConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setTypeParams(typeParams?: TSTypeParameterInstantiation): this {
+        global.generatedEs2panda._CallExpressionSetTypeParams(global.context, this.peer, passNode(typeParams))
+        return this
+    }
+    /** @deprecated */
+    setTrailingBlock(block?: BlockStatement): this {
+        global.generatedEs2panda._CallExpressionSetTrailingBlock(global.context, this.peer, passNode(block))
+        return this
+    }
+    get isExtensionAccessorCall(): boolean {
+        return global.generatedEs2panda._CallExpressionIsExtensionAccessorCall(global.context, this.peer)
+    }
+    get trailingBlock(): BlockStatement | undefined {
+        return unpackNode(global.generatedEs2panda._CallExpressionTrailingBlockConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setIsTrailingBlockInNewLine(isNewLine: boolean): this {
+        global.generatedEs2panda._CallExpressionSetIsTrailingBlockInNewLine(global.context, this.peer, isNewLine)
+        return this
+    }
+    get isTrailingBlockInNewLine(): boolean {
+        return global.generatedEs2panda._CallExpressionIsTrailingBlockInNewLineConst(global.context, this.peer)
+    }
+    get isETSConstructorCall(): boolean {
+        return global.generatedEs2panda._CallExpressionIsETSConstructorCallConst(global.context, this.peer)
+    }
+}
+export function isCallExpression(node: object | undefined): node is CallExpression {
+    return node instanceof CallExpression
+}
+if (!nodeByType.has(10)) {
+    nodeByType.set(10, CallExpression)
+}

package/build/libarkts-copy/src/generated/peers/CatchClause.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 { BlockStatement } from "./BlockStatement"
+import { Expression } from "./Expression"
+import { TypedStatement } from "./TypedStatement"
+export class CatchClause extends TypedStatement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 11)
+        super(pointer)
+    }
+    static createCatchClause(param?: Expression, body?: BlockStatement): CatchClause {
+        return new CatchClause(global.generatedEs2panda._CreateCatchClause(global.context, passNode(param), passNode(body)))
+    }
+    static updateCatchClause(original?: CatchClause, param?: Expression, body?: BlockStatement): CatchClause {
+        return new CatchClause(global.generatedEs2panda._UpdateCatchClause(global.context, passNode(original), passNode(param), passNode(body)))
+    }
+    static update1CatchClause(original?: CatchClause, other?: CatchClause): CatchClause {
+        return new CatchClause(global.generatedEs2panda._UpdateCatchClause1(global.context, passNode(original), passNode(other)))
+    }
+    get param(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._CatchClauseParamConst(global.context, this.peer))
+    }
+    get body(): BlockStatement | undefined {
+        return unpackNode(global.generatedEs2panda._CatchClauseBodyConst(global.context, this.peer))
+    }
+    get isDefaultCatchClause(): boolean {
+        return global.generatedEs2panda._CatchClauseIsDefaultCatchClauseConst(global.context, this.peer)
+    }
+}
+export function isCatchClause(node: object | undefined): node is CatchClause {
+    return node instanceof CatchClause
+}
+if (!nodeByType.has(11)) {
+    nodeByType.set(11, CatchClause)
+}

package/build/libarkts-copy/src/generated/peers/ChainExpression.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 ChainExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 12)
+        super(pointer)
+    }
+    static createChainExpression(expression?: Expression): ChainExpression {
+        return new ChainExpression(global.generatedEs2panda._CreateChainExpression(global.context, passNode(expression)))
+    }
+    static updateChainExpression(original?: ChainExpression, expression?: Expression): ChainExpression {
+        return new ChainExpression(global.generatedEs2panda._UpdateChainExpression(global.context, passNode(original), passNode(expression)))
+    }
+    get expression(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ChainExpressionGetExpressionConst(global.context, this.peer))
+    }
+}
+export function isChainExpression(node: object | undefined): node is ChainExpression {
+    return node instanceof ChainExpression
+}
+if (!nodeByType.has(12)) {
+    nodeByType.set(12, ChainExpression)
+}

package/build/libarkts-copy/src/generated/peers/CharLiteral.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 CharLiteral extends Literal {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 13)
+        super(pointer)
+    }
+    static createCharLiteral(): CharLiteral {
+        return new CharLiteral(global.generatedEs2panda._CreateCharLiteral(global.context))
+    }
+    static updateCharLiteral(original?: CharLiteral): CharLiteral {
+        return new CharLiteral(global.generatedEs2panda._UpdateCharLiteral(global.context, passNode(original)))
+    }
+}
+export function isCharLiteral(node: object | undefined): node is CharLiteral {
+    return node instanceof CharLiteral
+}
+if (!nodeByType.has(13)) {
+    nodeByType.set(13, CharLiteral)
+}

package/build/libarkts-copy/src/generated/peers/ClassDeclaration.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 { ClassDefinition } from "./ClassDefinition"
+import { Decorator } from "./Decorator"
+import { Statement } from "./Statement"
+export class ClassDeclaration extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 15)
+        super(pointer)
+    }
+    static createClassDeclaration(def?: ClassDefinition): ClassDeclaration {
+        return new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def)))
+    }
+    static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition): ClassDeclaration {
+        return new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def)))
+    }
+    get definition(): ClassDefinition | undefined {
+        return unpackNode(global.generatedEs2panda._ClassDeclarationDefinitionConst(global.context, this.peer))
+    }
+    get decorators(): readonly Decorator[] {
+        return unpackNodeArray(global.generatedEs2panda._ClassDeclarationDecoratorsConst(global.context, this.peer))
+    }
+}
+export function isClassDeclaration(node: object | undefined): node is ClassDeclaration {
+    return node instanceof ClassDeclaration
+}
+if (!nodeByType.has(15)) {
+    nodeByType.set(15, ClassDeclaration)
+}