@idlizer/core 2.1.5 → 2.1.9-arktscgen-4

package/build/lib/src/LanguageWriters/writers/CppLanguageWriter.js

@@ -15,7 +15,7 @@
 import { createReferenceType, forceAsNamedNode, IDLU32Type, IDLVoidType } from '../../idl';
 import { Language } from '../../Language';
 import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
-import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifier, NamedMethodSignature, StringExpression } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifier, NamedMethodSignature, StringExpression, MethodStaticCallExpression } from "../LanguageWriter";
 import { CDefinedExpression, CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
 import { RuntimeType } from "../common";
 import { IndentedPrinter } from "../../IndentedPrinter";
@@ -66,6 +66,11 @@ export class CppPointerPropertyAccessExpression {
         return `${this.expression}->${this.name}`;
     }
 }
+export class CPPMethodStaticCallExpression extends MethodStaticCallExpression {
+    asString() {
+        return `${this.receiver}::${this.name}(${this.params.map(it => it.asString()).join(', ')})`;
+    }
+}
 ////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
 ////////////////////////////////////////////////////////////////
@@ -162,8 +167,13 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     constructor(printer, resolver, typeConvertor, primitivesTypes) {
         super(printer, resolver, Language.CPP);
         this.primitivesTypes = primitivesTypes;
+        this.classMode = 'normal';
+        this.currentClass = [];
         this.typeConvertor = typeConvertor;
     }
+    changeModeTo(mode) {
+        this.classMode = mode;
+    }
     getNodeName(type) {
         return this.typeConvertor.convert(type);
     }
@@ -171,14 +181,28 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         var _a;
         return new CppLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
     }
+    writeDeclaration(name, signature, modifiers, postfix) {
+        const realName = this.classMode === 'normal' ? name : `${this.currentClass.at(0)}::${name}`;
+        const newModifiers = this.classMode === 'normal'
+            ? modifiers
+            : (modifiers !== null && modifiers !== void 0 ? modifiers : []).filter(it => it !== MethodModifier.STATIC).concat(MethodModifier.INLINE);
+        super.writeDeclaration(realName, signature, newModifiers, postfix);
+    }
     writeClass(name, op, superClass, interfaces) {
-        const superClasses = (superClass ? [superClass] : []).concat(interfaces !== null && interfaces !== void 0 ? interfaces : []);
-        const extendsClause = superClasses.length > 0 ? ` : ${superClasses.map(c => `public ${c}`).join(", ")}` : '';
-        this.printer.print(`class ${name}${extendsClause} {`);
-        this.pushIndent();
+        if (this.classMode === 'normal') {
+            const superClasses = (superClass ? [superClass] : []).concat(interfaces !== null && interfaces !== void 0 ? interfaces : []);
+            const extendsClause = superClasses.length > 0 ? ` : ${superClasses.map(c => `public ${c}`).join(", ")}` : '';
+            this.printer.print(`class ${name}${extendsClause} {`);
+            this.pushIndent();
+        }
+        if (this.classMode === 'detached') {
+            this.currentClass.push(name);
+        }
         op(this);
-        this.popIndent();
-        this.printer.print(`};`);
+        if (this.classMode === 'normal') {
+            this.popIndent();
+            this.printer.print(`};`);
+        }
     }
     writeInterface(name, op, superInterfaces, generics) {
         throw new Error("Method not implemented.");
@@ -191,6 +215,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
             super.writeMethodCall(receiver, method, params, nullable);
         }
     }
+    writeStaticMethodCall(receiver, method, params, nullable) {
+        this.printer.print(`${receiver}::${method}(${params.join(', ')});`);
+    }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
         let filter = function (modifier_name) {
             return modifier_name !== FieldModifier.STATIC;
@@ -201,9 +228,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         this.printer.print(`${forceAsNamedNode(type).name} ${name};`);
         this.printer.popIndent();
     }
-    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
-        const superInvocation = superCall
-            ? ` : ${superCall.name}(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`
+    writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
+        const superInvocation = delegationCall
+            ? ` : ${delegationCall.delegationName}(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")})`
             : "";
         const argList = signature.args.map((it, index) => {
             var _a;
@@ -293,6 +320,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     makeUnionVariantCast(value, type, convertor, index) {
         return this.makeString(`${value}.value${index}`);
     }
+    makeStaticMethodCall(receiver, method, params, nullable) {
+        return new CPPMethodStaticCallExpression(receiver, method, params, nullable);
+    }
     makeLoop(counter, limit, statement) {
         return new CLikeLoopStatement(counter, limit, statement);
     }
@@ -435,6 +465,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
             case PrintHint.AsPointer:
                 postfix = '*';
                 break;
+            case PrintHint.AsReference:
+                postfix = '&';
+                break;
             case PrintHint.AsConstPointer:
                 constModifier = 'const ';
                 postfix = '*';

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.d.ts

@@ -31,8 +31,8 @@ export declare class ETSLambdaExpression extends LambdaExpression {
     asString(): string;
 }
 export declare function generateTypeCheckerName(typeName: string): string;
-export declare function generateEnumToNumericName(typeName: string): string;
-export declare function generateEnumFromNumericName(typeName: string): string;
+export declare function generateEnumToNumericName(entry: idl.IDLEntry): string;
+export declare function generateEnumFromNumericName(entry: idl.IDLEntry): string;
 export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName: string, writer: LanguageWriter): LanguageExpression;
 export declare class ETSLanguageWriter extends TSLanguageWriter {
     private arrayConvertor;
@@ -73,6 +73,9 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
+    static _isUseTypeChecker: boolean;
+    static get isUseTypeChecker(): boolean;
+    static useTypeChecker<T>(isUseTypeChecker: boolean, op: () => T): T;
 }
 export declare function makeEnumTypeCheckerCall(valueAccessor: string, enumName: string, writer: LanguageWriter): LanguageExpression;
 //# sourceMappingURL=ETSLanguageWriter.d.ts.map

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.js

@@ -130,16 +130,17 @@ export class ETSLambdaExpression extends LambdaExpression {
 //                           UTILS                            //
 ////////////////////////////////////////////////////////////////
 export function generateTypeCheckerName(typeName) {
-    typeName = typeName.replaceAll('[]', 'BracketsArray')
-        .replaceAll('.', ''); // Todo: hack for namespaces
+    typeName = typeName
+        .replaceAll('[]', 'BracketsArray')
+        .split('.').join('_');
     return `is${typeName.replaceAll('[]', 'Brackets')}`;
 }
-export function generateEnumToNumericName(typeName) {
-    typeName = typeName.split(".").join("_");
+export function generateEnumToNumericName(entry) {
+    const typeName = idl.getQualifiedName(entry, "namespace.name").split('.').join('_');
     return `${typeName}_ToNumeric`;
 }
-export function generateEnumFromNumericName(typeName) {
-    typeName = typeName.split(".").join("_");
+export function generateEnumFromNumericName(entry) {
+    const typeName = idl.getQualifiedName(entry, "namespace.name").split('.').join('_');
     return `${typeName}_FromNumeric`;
 }
 export function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
@@ -168,7 +169,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return new ArkTSMapForEachStatement(map, key, value, op);
     }
     makeMapSize(map) {
-        return this.makeString(`${super.makeMapSize(map).asString()} as int32`); // TODO: cast really needed?
+        return this.makeString(`${super.makeMapSize(map).asString()}`); // TODO: cast really needed?
     }
     get supportedModifiers() {
         return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.NATIVE, MethodModifier.STATIC];
@@ -180,12 +181,21 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return this.makeString(`${value} as ${type}`);
     }
     i32FromEnum(value, enumEntry) {
-        const enumName = this.getNodeName(enumEntry);
-        return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumName), [value]);
+        if (ETSLanguageWriter.isUseTypeChecker) {
+            return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumEntry), [value]);
+        }
+        return idl.isStringEnum(enumEntry)
+            ? this.makeMethodCall(value.asString(), 'getOrdinal', [])
+            : this.makeMethodCall(value.asString(), 'valueOf', []);
     }
     enumFromI32(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumName), [value]);
+        if (ETSLanguageWriter.isUseTypeChecker) {
+            return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumEntry), [value]);
+        }
+        return idl.isStringEnum(enumEntry)
+            ? this.makeString(`${enumName}.values()[${value.asString()}]`)
+            : this.makeMethodCall(enumName, 'fromValue', [value]);
     }
     makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
         if (convertor instanceof AggregateConvertor
@@ -269,7 +279,12 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         // ])
     }
     castToInt(value, bitness) {
-        return `${value} as int32`; // FIXME: is there int8 in ARKTS?
+        // This fix is used to avoid unnecessary writeInt8(value as int32) call, which is generated if value is already an int32
+        // The explicit cast forces ui2abc to call valueOf on an int, which fails the compilation
+        // TODO Fix this cast
+        if (bitness === 8)
+            return `(${value}).toChar()`;
+        return `(${value}).toInt()`; // FIXME: is there int8 in ARKTS?
     }
     castToBoolean(value) { return `${value} ? 1 : 0`; }
     instanceOf(convertor, value, duplicateMembers) {
@@ -306,9 +321,28 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     }
     makeCast(value, node, options) {
         var _a;
+        if (node === idl.IDLI64Type)
+            return this.makeMethodCall(value.asString(), `toLong`, []);
+        if (node === idl.IDLI32Type)
+            return this.makeMethodCall(value.asString(), `toInt`, []);
+        if (node === idl.IDLI8Type)
+            return this.makeMethodCall(value.asString(), `toByte`, []);
+        if (node === idl.IDLF64Type)
+            return this.makeMethodCall(value.asString(), `toDouble`, []);
+        if (node === idl.IDLF32Type)
+            return this.makeMethodCall(value.asString(), `toFloat`, []);
         return new TSCastExpression(value, `${this.getNodeName(node)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
+    static get isUseTypeChecker() { return this._isUseTypeChecker; }
+    static useTypeChecker(isUseTypeChecker, op) {
+        const prevIsUse = this.isReferenceRelativeToNamespaces;
+        this._isUseTypeChecker = isUseTypeChecker;
+        const result = op();
+        this._isUseTypeChecker = prevIsUse;
+        return result;
+    }
 }
+ETSLanguageWriter._isUseTypeChecker = true;
 function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {
     return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(interfaceName), [writer.makeString(valueAccessor),
         ...allFields.map(it => {

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.d.ts

@@ -1,5 +1,5 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { AssignStatement, DelegationCall, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
 import { CLikeLanguageWriter } from "./CLikeLanguageWriter";
 import * as idl from '../../idl';
 import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
@@ -39,7 +39,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeNativeMethodDeclaration(method: Method): void;
-    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
+    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, delegationCall?: DelegationCall, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
         method: Method;
         op: () => void;

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.js

@@ -146,11 +146,11 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     writeNativeMethodDeclaration(method) {
         this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
     }
-    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
+    writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
         this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') : ''} ${className}(${signature.args.map((it, index) => `${this.getNodeName(it)} ${signature.argName(index)}`).join(", ")}) {`);
         this.pushIndent();
-        if (superCall) {
-            this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")});`);
+        if (delegationCall) {
+            this.print(`super(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")});`);
         }
         op(this);
         this.popIndent();

package/build/lib/src/LanguageWriters/writers/KotlinLanguageWriter.d.ts

@@ -0,0 +1,149 @@
+import * as idl from '../../idl';
+import { Language } from '../../Language';
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { AssignStatement, DelegationCall, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { ArgConvertor } from "../ArgConvertors";
+import { IdlNameConvertor } from "../nameConvertor";
+import { RuntimeType } from "../common";
+import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class KotlinEnumEntityStatement implements LanguageStatement {
+    private readonly enumEntity;
+    private readonly options;
+    constructor(enumEntity: idl.IDLEnum, options: {
+        isExport: boolean;
+        isDeclare: boolean;
+    });
+    write(writer: LanguageWriter): void;
+    private maybeQuoted;
+}
+export declare class KotlinEnumWithGetter implements LanguageStatement {
+    private readonly enumEntity;
+    private readonly isExport;
+    constructor(enumEntity: idl.IDLEnum, isExport: boolean);
+    write(writer: LanguageWriter): void;
+}
+export declare class KotlinThrowErrorStatement implements LanguageStatement {
+    message: string;
+    constructor(message: string);
+    write(writer: LanguageWriter): void;
+}
+export declare class KotlinLoopStatement implements LanguageStatement {
+    private counter;
+    private limit;
+    private statement;
+    constructor(counter: string, limit: string, statement: LanguageStatement | undefined);
+    write(writer: LanguageWriter): void;
+}
+export declare class KotlinAssignStatement extends AssignStatement {
+    variableName: string;
+    type: idl.IDLType | undefined;
+    expression: LanguageExpression;
+    isDeclared: boolean;
+    isConst: boolean;
+    constructor(variableName: string, type: idl.IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean);
+    write(writer: LanguageWriter): void;
+}
+export declare class KotlinNewObjectExpression implements LanguageExpression {
+    private objectName;
+    private params;
+    constructor(objectName: string, params: LanguageExpression[]);
+    asString(): string;
+}
+export declare class KotlinCheckDefinedExpression implements LanguageExpression {
+    private value;
+    constructor(value: string);
+    asString(): string;
+}
+export declare class KotlinLanguageWriter extends LanguageWriter {
+    protected typeConvertor: IdlNameConvertor;
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, language?: Language);
+    fork(options?: {
+        resolver?: ReferenceResolver;
+    }): LanguageWriter;
+    getNodeName(type: idl.IDLNode): string;
+    writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isAbstract?: boolean): void;
+    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[], isDeclared?: boolean): void;
+    writeFunctionDeclaration(name: string, signature: MethodSignature, generics?: string[]): void;
+    writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void, generics?: string[]): void;
+    private generateFunctionDeclaration;
+    writeEnum(name: string, members: {
+        name: string;
+        alias?: string | undefined;
+        stringId: string | undefined;
+        numberId: number;
+    }[], options: {
+        isDeclare?: boolean;
+        isExport: boolean;
+    }): void;
+    private writeDeclaration;
+    writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
+    writeNativeMethodDeclaration(method: Method): void;
+    writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
+    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, delegationCall?: DelegationCall, modifiers?: MethodModifier[]): void;
+    writeMethodImplementation(method: Method, op: (writer: this) => void): void;
+    writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
+    writeGetterImplementation(method: Method, op?: (writer: this) => void): void;
+    writeSetterImplementation(method: Method, op: (writer: this) => void): void;
+    writeTypeDeclaration(decl: idl.IDLTypedef): void;
+    writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
+    makeNull(): LanguageExpression;
+    makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
+    makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
+    makeThrowError(message: string): LanguageStatement;
+    makeReturn(expr: LanguageExpression): LanguageStatement;
+    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
+    makeStatement(expr: LanguageExpression): LanguageStatement;
+    makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    writePrintLog(message: string): void;
+    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
+    typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
+    getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
+    makeUndefined(): LanguageExpression;
+    makeRuntimeType(rt: RuntimeType): LanguageExpression;
+    makeTupleAlloc(option: string): LanguageStatement;
+    makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
+    makeArrayLength(array: string, length?: string): LanguageExpression;
+    makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
+    makeMapInit(type: idl.IDLType): LanguageExpression;
+    makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
+    makeUnwrapOptional(expression: LanguageExpression): LanguageExpression;
+    makeDefinedCheck(value: string): LanguageExpression;
+    makeUnionSelector(value: string, valueType: string): LanguageStatement;
+    makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
+    makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
+    makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, _convertorIndex?: number, _runtimeTypeIndex?: number): LanguageExpression;
+    makeRuntimeTypeCondition(typeVarName: string, equals: boolean, type: RuntimeType, varName: string): LanguageExpression;
+    getTagType(): idl.IDLType;
+    getRuntimeType(): idl.IDLType;
+    makeTupleAssign(receiver: string, fields: string[]): LanguageStatement;
+    get supportedModifiers(): MethodModifier[];
+    get supportedFieldModifiers(): FieldModifier[];
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    makeEnumEntity(enumEntity: idl.IDLEnum, options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }): LanguageStatement;
+    castToBoolean(value: string): string;
+    castToInt(value: string, bitness: 8 | 32): string;
+    makeCallIsObject(value: string): LanguageExpression;
+    makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
+    escapeKeyword(keyword: string): string;
+    makeDiscriminatorConvertor(convertor: ArgConvertor, value: string, index: number): LanguageExpression | undefined;
+    makeStaticBlock(op: (writer: LanguageWriter) => void): void;
+    pushNamespace(namespace: string, options: {
+        ident: boolean;
+        isDeclared?: boolean;
+    }): void;
+    popNamespace(options: {
+        ident: boolean;
+    }): void;
+}
+//# sourceMappingURL=KotlinLanguageWriter.d.ts.map