@idlizer/arktscgen 2.1.2

package/build/libarkts-copy/src/generated/peers/StringLiteral.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 { Literal } from "./Literal"
+export class StringLiteral extends Literal {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 61)
+        super(pointer)
+    }
+    static create1StringLiteral(str: string): StringLiteral {
+        return new StringLiteral(global.generatedEs2panda._CreateStringLiteral1(global.context, str))
+    }
+    static updateStringLiteral(original?: StringLiteral): StringLiteral {
+        return new StringLiteral(global.generatedEs2panda._UpdateStringLiteral(global.context, passNode(original)))
+    }
+    static update1StringLiteral(original: StringLiteral | undefined, str: string): StringLiteral {
+        return new StringLiteral(global.generatedEs2panda._UpdateStringLiteral1(global.context, passNode(original), str))
+    }
+    get str(): string {
+        return unpackString(global.generatedEs2panda._StringLiteralStrConst(global.context, this.peer))
+    }
+}
+export function isStringLiteral(node: object | undefined): node is StringLiteral {
+    return node instanceof StringLiteral
+}
+if (!nodeByType.has(61)) {
+    nodeByType.set(61, StringLiteral)
+}

package/build/libarkts-copy/src/generated/peers/SuperExpression.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 SuperExpression extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 82)
+        super(pointer)
+    }
+    static createSuperExpression(): SuperExpression {
+        return new SuperExpression(global.generatedEs2panda._CreateSuperExpression(global.context))
+    }
+    static updateSuperExpression(original?: SuperExpression): SuperExpression {
+        return new SuperExpression(global.generatedEs2panda._UpdateSuperExpression(global.context, passNode(original)))
+    }
+}
+export function isSuperExpression(node: object | undefined): node is SuperExpression {
+    return node instanceof SuperExpression
+}
+if (!nodeByType.has(82)) {
+    nodeByType.set(82, SuperExpression)
+}

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

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    Es2pandaAstNodeType,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { Expression } from "./Expression"
+import { Statement } from "./Statement"
+export class SwitchCaseStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 84)
+        super(pointer)
+    }
+    static createSwitchCaseStatement(test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement {
+        return new SwitchCaseStatement(global.generatedEs2panda._CreateSwitchCaseStatement(global.context, passNode(test), passNodeArray(consequent), consequent.length))
+    }
+    static updateSwitchCaseStatement(original: SwitchCaseStatement | undefined, test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement {
+        return new SwitchCaseStatement(global.generatedEs2panda._UpdateSwitchCaseStatement(global.context, passNode(original), passNode(test), passNodeArray(consequent), consequent.length))
+    }
+    get test(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._SwitchCaseStatementTestConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTest(test?: Expression): this {
+        global.generatedEs2panda._SwitchCaseStatementSetTest(global.context, this.peer, passNode(test))
+        return this
+    }
+    get consequent(): readonly Statement[] {
+        return unpackNodeArray(global.generatedEs2panda._SwitchCaseStatementConsequentConst(global.context, this.peer))
+    }
+}
+export function isSwitchCaseStatement(node: object | undefined): node is SwitchCaseStatement {
+    return node instanceof SwitchCaseStatement
+}
+if (!nodeByType.has(84)) {
+    nodeByType.set(84, SwitchCaseStatement)
+}

package/build/libarkts-copy/src/generated/peers/SwitchStatement.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 { Expression } from "./Expression"
+import { Statement } from "./Statement"
+import { SwitchCaseStatement } from "./SwitchCaseStatement"
+export class SwitchStatement extends Statement {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 85)
+        super(pointer)
+    }
+    static createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement {
+        return new SwitchStatement(global.generatedEs2panda._CreateSwitchStatement(global.context, passNode(discriminant), passNodeArray(cases), cases.length))
+    }
+    static updateSwitchStatement(original: SwitchStatement | undefined, discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement {
+        return new SwitchStatement(global.generatedEs2panda._UpdateSwitchStatement(global.context, passNode(original), passNode(discriminant), passNodeArray(cases), cases.length))
+    }
+    get discriminant(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._SwitchStatementDiscriminantConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setDiscriminant(discriminant?: Expression): this {
+        global.generatedEs2panda._SwitchStatementSetDiscriminant(global.context, this.peer, passNode(discriminant))
+        return this
+    }
+    get cases(): readonly SwitchCaseStatement[] {
+        return unpackNodeArray(global.generatedEs2panda._SwitchStatementCasesConst(global.context, this.peer))
+    }
+}
+export function isSwitchStatement(node: object | undefined): node is SwitchStatement {
+    return node instanceof SwitchStatement
+}
+if (!nodeByType.has(85)) {
+    nodeByType.set(85, SwitchStatement)
+}

package/build/libarkts-copy/src/generated/peers/TSAnyKeyword.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 TSAnyKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 90)
+        super(pointer)
+    }
+    static createTSAnyKeyword(): TSAnyKeyword {
+        return new TSAnyKeyword(global.generatedEs2panda._CreateTSAnyKeyword(global.context))
+    }
+    static updateTSAnyKeyword(original?: TSAnyKeyword): TSAnyKeyword {
+        return new TSAnyKeyword(global.generatedEs2panda._UpdateTSAnyKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSAnyKeyword(node: object | undefined): node is TSAnyKeyword {
+    return node instanceof TSAnyKeyword
+}
+if (!nodeByType.has(90)) {
+    nodeByType.set(90, TSAnyKeyword)
+}

package/build/libarkts-copy/src/generated/peers/TSArrayType.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 { TypeNode } from "./TypeNode"
+export class TSArrayType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 101)
+        super(pointer)
+    }
+    static createTSArrayType(elementType?: TypeNode): TSArrayType {
+        return new TSArrayType(global.generatedEs2panda._CreateTSArrayType(global.context, passNode(elementType)))
+    }
+    static updateTSArrayType(original?: TSArrayType, elementType?: TypeNode): TSArrayType {
+        return new TSArrayType(global.generatedEs2panda._UpdateTSArrayType(global.context, passNode(original), passNode(elementType)))
+    }
+    get elementType(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSArrayTypeElementTypeConst(global.context, this.peer))
+    }
+}
+export function isTSArrayType(node: object | undefined): node is TSArrayType {
+    return node instanceof TSArrayType
+}
+if (!nodeByType.has(101)) {
+    nodeByType.set(101, TSArrayType)
+}

package/build/libarkts-copy/src/generated/peers/TSAsExpression.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 { AnnotatedExpression } from "./AnnotatedExpression"
+import { Expression } from "./Expression"
+import { TypeNode } from "./TypeNode"
+export class TSAsExpression extends AnnotatedExpression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 137)
+        super(pointer)
+    }
+    static createTSAsExpression(expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression {
+        return new TSAsExpression(global.generatedEs2panda._CreateTSAsExpression(global.context, passNode(expression), passNode(typeAnnotation), isConst))
+    }
+    static updateTSAsExpression(original: TSAsExpression | undefined, expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression {
+        return new TSAsExpression(global.generatedEs2panda._UpdateTSAsExpression(global.context, passNode(original), passNode(expression), passNode(typeAnnotation), isConst))
+    }
+    get expr(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSAsExpressionExprConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setExpr(expr?: Expression): this {
+        global.generatedEs2panda._TSAsExpressionSetExpr(global.context, this.peer, passNode(expr))
+        return this
+    }
+    get isConst(): boolean {
+        return global.generatedEs2panda._TSAsExpressionIsConstConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setUncheckedCast(isUncheckedCast: boolean): this {
+        global.generatedEs2panda._TSAsExpressionSetUncheckedCast(global.context, this.peer, isUncheckedCast)
+        return this
+    }
+    get typeAnnotation(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._TSAsExpressionTypeAnnotationConst(global.context, this.peer))
+    }
+    /** @deprecated */
+    setTsTypeAnnotation(typeAnnotation?: TypeNode): this {
+        global.generatedEs2panda._TSAsExpressionSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation))
+        return this
+    }
+}
+export function isTSAsExpression(node: object | undefined): node is TSAsExpression {
+    return node instanceof TSAsExpression
+}
+if (!nodeByType.has(137)) {
+    nodeByType.set(137, TSAsExpression)
+}

package/build/libarkts-copy/src/generated/peers/TSBigintKeyword.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 TSBigintKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 97)
+        super(pointer)
+    }
+    static createTSBigintKeyword(): TSBigintKeyword {
+        return new TSBigintKeyword(global.generatedEs2panda._CreateTSBigintKeyword(global.context))
+    }
+    static updateTSBigintKeyword(original?: TSBigintKeyword): TSBigintKeyword {
+        return new TSBigintKeyword(global.generatedEs2panda._UpdateTSBigintKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSBigintKeyword(node: object | undefined): node is TSBigintKeyword {
+    return node instanceof TSBigintKeyword
+}
+if (!nodeByType.has(97)) {
+    nodeByType.set(97, TSBigintKeyword)
+}

package/build/libarkts-copy/src/generated/peers/TSBooleanKeyword.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 TSBooleanKeyword extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 92)
+        super(pointer)
+    }
+    static createTSBooleanKeyword(): TSBooleanKeyword {
+        return new TSBooleanKeyword(global.generatedEs2panda._CreateTSBooleanKeyword(global.context))
+    }
+    static updateTSBooleanKeyword(original?: TSBooleanKeyword): TSBooleanKeyword {
+        return new TSBooleanKeyword(global.generatedEs2panda._UpdateTSBooleanKeyword(global.context, passNode(original)))
+    }
+}
+export function isTSBooleanKeyword(node: object | undefined): node is TSBooleanKeyword {
+    return node instanceof TSBooleanKeyword
+}
+if (!nodeByType.has(92)) {
+    nodeByType.set(92, TSBooleanKeyword)
+}

package/build/libarkts-copy/src/generated/peers/TSClassImplements.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 { Expression } from "./Expression"
+import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
+export class TSClassImplements extends Expression {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 138)
+        super(pointer)
+    }
+    static createTSClassImplements(expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements {
+        return new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements(global.context, passNode(expression), passNode(typeParameters)))
+    }
+    static updateTSClassImplements(original?: TSClassImplements, expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements {
+        return new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements(global.context, passNode(original), passNode(expression), passNode(typeParameters)))
+    }
+    static update1TSClassImplements(original?: TSClassImplements, expression?: Expression): TSClassImplements {
+        return new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements1(global.context, passNode(original), passNode(expression)))
+    }
+    get expr(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSClassImplementsExprConst(global.context, this.peer))
+    }
+    get typeParameters(): TSTypeParameterInstantiation | undefined {
+        return unpackNode(global.generatedEs2panda._TSClassImplementsTypeParametersConst(global.context, this.peer))
+    }
+}
+export function isTSClassImplements(node: object | undefined): node is TSClassImplements {
+    return node instanceof TSClassImplements
+}
+if (!nodeByType.has(138)) {
+    nodeByType.set(138, TSClassImplements)
+}

package/build/libarkts-copy/src/generated/peers/TSConditionalType.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 { Expression } from "./Expression"
+import { TypeNode } from "./TypeNode"
+export class TSConditionalType extends TypeNode {
+     constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 110)
+        super(pointer)
+    }
+    static createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType {
+        return new TSConditionalType(global.generatedEs2panda._CreateTSConditionalType(global.context, passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType)))
+    }
+    static updateTSConditionalType(original?: TSConditionalType, checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType {
+        return new TSConditionalType(global.generatedEs2panda._UpdateTSConditionalType(global.context, passNode(original), passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType)))
+    }
+    get checkType(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSConditionalTypeCheckTypeConst(global.context, this.peer))
+    }
+    get extendsType(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSConditionalTypeExtendsTypeConst(global.context, this.peer))
+    }
+    get trueType(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSConditionalTypeTrueTypeConst(global.context, this.peer))
+    }
+    get falseType(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._TSConditionalTypeFalseTypeConst(global.context, this.peer))
+    }
+}
+export function isTSConditionalType(node: object | undefined): node is TSConditionalType {
+    return node instanceof TSConditionalType
+}
+if (!nodeByType.has(110)) {
+    nodeByType.set(110, TSConditionalType)
+}