@idlizer/core 2.1.2 → 2.1.5

package/build/lib/src/LanguageWriters/convertors/CppConvertors.js

@@ -70,7 +70,7 @@ export class GenericCppConvertor {
     }
     /////////////////////////////////////////////////////////////////////////////////////////
     convertOptional(type) {
-        return this.convertNode(type.type);
+        return { text: generatorConfiguration().OptionalPrefix + this.convertNode(type.type).text, noPrefix: true };
     }
     convertUnion(type) {
         return this.make(type.name, false);
@@ -90,16 +90,21 @@ export class GenericCppConvertor {
         }
         throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
     }
-    convertImport(type, _) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
         return this.make(idl.IDLCustomObjectType.name);
     }
+    convertTypeReferenceAsImport(type, _) {
+        return this.convertTypeReference(type);
+    }
     convertTypeReference(type) {
         var _a;
         const refName = type.name;
         switch (refName) {
             case "object":
             case "Object":
-                return this.make('CustomObject');
+                // treat object as interop resource
+                return this.make('Object');
         }
         if (generatorConfiguration().parameterized.includes(refName)) {
             return this.make('CustomObject');
@@ -138,13 +143,12 @@ export class GenericCppConvertor {
             case idl.IDLNumberType: return this.make(`Number`);
             case idl.IDLStringType: return this.make(`String`);
             case idl.IDLBooleanType: return this.make(`Boolean`);
-            case idl.IDLBigintType: return this.make(`UInt64`); // TODO add arbitrary precision numeric type
+            case idl.IDLBigintType: return this.make(`Int64`); // TODO add arbitrary precision numeric type
             case idl.IDLPointerType: return this.make('NativePointer');
             case idl.IDLCustomObjectType: return this.make('CustomObject');
             case idl.IDLUnknownType:
             case idl.IDLAnyType: return this.make(`Object`);
             case idl.IDLUndefinedType: return this.make(`Undefined`);
-            case idl.IDLLengthType: return this.make(`Length`);
             case idl.IDLFunctionType: return this.make(`Function`);
             case idl.IDLDate: return this.make(`Date`);
             case idl.IDLBufferType: return this.make('Buffer');
@@ -154,7 +158,7 @@ export class GenericCppConvertor {
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }
     qualifiedName(target) {
-        return qualifiedName(target, "_");
+        return qualifiedName(target, "_", "namespace.name");
     }
     computeTargetTypeLiteralName(decl) {
         const map = new Map();
@@ -171,9 +175,6 @@ export class GenericCppConvertor {
 export class CppConvertor extends GenericCppConvertor {
     unwrap(type, result) {
         const conf = generatorConfiguration();
-        if (idl.isType(type) && idl.isOptionalType(type)) {
-            return `${conf.OptionalPrefix}${result.text}`;
-        }
         if (result.noPrefix) {
             return result.text;
         }
@@ -187,12 +188,16 @@ export class CppConvertor extends GenericCppConvertor {
         if (!idl.isType(type))
             return false;
         const { resolver } = this;
+        const seen = new Set;
         while (type && idl.isReferenceType(type)) {
             const resolved = resolver.resolveTypeReference(type);
             if (!resolved)
                 return false;
             if (!idl.isTypedef(resolved))
                 break;
+            if (seen.has(resolved))
+                return false;
+            seen.add(resolved);
             type = resolved.type;
         }
         return idl.isPrimitiveType(type);
@@ -221,7 +226,6 @@ export class CppInteropArgConvertor extends InteropArgConvertor {
             case idl.IDLNumberType: return "KInteropNumber";
             case idl.IDLSerializerBuffer: return "KSerializerBuffer";
             case idl.IDLBufferType: return "KInteropBuffer";
-            case idl.IDLLengthType: return "KLength";
             case idl.IDLFunctionType: return PrimitiveTypesInstance.Int32.getText();
             case idl.IDLDate: return PrimitiveTypesInstance.Int64.getText();
             case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
@@ -247,7 +251,11 @@ export class CppReturnTypeConvertor {
             return 'void';
         return this.convertor.convert(type);
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
+        return "void";
+    }
+    convertTypeReferenceAsImport(type, importClause) {
         return this.convertor.convert(type);
     }
     convertOptional(type) {
@@ -264,7 +272,7 @@ export class CppReturnTypeConvertor {
     convertTypeReference(type) {
         const decl = this.resolver.resolveTypeReference(type);
         if (decl && idl.isInterface(decl) && isMaterialized(decl, this.resolver)) {
-            return generatorTypePrefix() + qualifiedName(decl, "_");
+            return generatorTypePrefix() + qualifiedName(decl, "_", "namespace.name");
         }
         return this.convertor.convert(type);
     }

package/build/lib/src/LanguageWriters/convertors/ETSConvertors.js

@@ -13,27 +13,16 @@
  * limitations under the License.
  */
 import * as idl from "../../idl";
-import { Language } from "../../Language";
-import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
-import { convertDeclaration } from "../nameConvertor";
+import { LanguageWriter } from "../LanguageWriter";
 import { TSInteropArgConvertor, TSTypeNameConvertor } from "./TSConvertors";
 export class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type) {
-        // Only to deal with namespaces. TODO: remove later
-        const decl = this.resolver.resolveTypeReference(type);
-        if (decl && idl.isEnum(decl)) {
-            return convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), decl);
+        let typeName = super.convertTypeReference(type);
+        if (LanguageWriter.isReferenceRelativeToNamespaces && idl.isReferenceType(type)) {
+            const namespacesPath = idl.getNamespacesPathFor(type).map(it => `${it.name}.`).join("");
+            if (typeName.startsWith(namespacesPath))
+                typeName = typeName.substring(namespacesPath.length);
         }
-        // TODO: Needs to be implemented properly
-        const types = type.name.split(".");
-        if (types.length > 1) {
-            // Takes only name without the namespace prefix
-            const decl = this.resolver.resolveTypeReference(idl.createReferenceType(types.slice(-1).join()));
-            if (decl !== undefined) {
-                return convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), decl);
-            }
-        }
-        const typeName = super.convertTypeReference(type);
         // TODO: Fix for 'TypeError: Type 'Function<R>' is generic but type argument were not provided.'
         if (typeName === "Function") {
             return "Function<void>";
@@ -77,6 +66,7 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
             case idl.IDLStringType: return 'string';
             case idl.IDLFunctionType: return 'Object';
             case idl.IDLBigintType: return 'long';
+            case idl.IDLCustomObjectType: return 'object';
         }
         return super.convertPrimitiveType(type);
     }

package/build/lib/src/LanguageWriters/convertors/InteropConvertors.d.ts

@@ -9,7 +9,8 @@ export declare class InteropReturnTypeConvertor implements TypeConvertor<string>
     isReturnInteropBuffer(type: idl.IDLType): boolean;
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertOptional(type: idl.IDLOptionalType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
@@ -19,7 +20,8 @@ export declare class InteropReturnTypeConvertor implements TypeConvertor<string>
 export declare class InteropArgConvertor implements TypeConvertor<string> {
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertOptional(type: idl.IDLOptionalType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;

package/build/lib/src/LanguageWriters/convertors/InteropConvertors.js

@@ -37,9 +37,12 @@ export class InteropReturnTypeConvertor {
         }
         return KInteropReturnBuffer;
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
         throw new Error(`Cannot pass import type ${type.name} through interop`);
     }
+    convertTypeReferenceAsImport(type, importClause) {
+        return this.convertTypeReference(type);
+    }
     convertOptional(type) {
         return KInteropReturnBuffer;
     }
@@ -105,7 +108,10 @@ export class InteropArgConvertor {
     convertContainer(type) {
         throw new Error(`Cannot pass container types through interop`);
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
+    convertTypeReferenceAsImport(type, importClause) {
         throw new Error(`Cannot pass import types through interop`);
     }
     convertOptional(type) {
@@ -116,6 +122,7 @@ export class InteropArgConvertor {
             case idl.IDLI64Type: return "KLong";
             case idl.IDLU64Type: return "KLong";
             case idl.IDLI32Type: return "KInt";
+            case idl.IDLU32Type: return "KInt";
             case idl.IDLF32Type: return "KFloat";
             case idl.IDLNumberType: return 'KInteropNumber';
             case idl.IDLBigintType: return 'KLong';
@@ -124,7 +131,6 @@ export class InteropArgConvertor {
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';
             case idl.IDLBufferType: return `KInteropBuffer`;
-            case idl.IDLLengthType: return 'Length';
             case idl.IDLDate: return 'KLong';
             case idl.IDLUndefinedType:
             case idl.IDLVoidType:

package/build/lib/src/LanguageWriters/convertors/JavaConvertors.d.ts

@@ -17,7 +17,8 @@ export declare class JavaTypeNameConvertor implements NodeConvertor<string>, Idl
     convertCallback(type: idl.IDLCallback): string;
     convertMethod(type: idl.IDLMethod): string;
     convertConstant(type: idl.IDLConstant): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;

package/build/lib/src/LanguageWriters/convertors/JavaConvertors.js

@@ -84,13 +84,17 @@ export class JavaTypeNameConvertor {
     convertConstant(type) {
         throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
+        return type.name;
+    }
+    convertTypeReferenceAsImport(type, importClause) {
         return type.name;
     }
     convertTypeReference(type) {
         const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
         if (importAttr) {
-            return this.convertImport(type, importAttr);
+            return this.convertTypeReferenceAsImport(type, importAttr);
         }
         const decl = this.resolver.resolveTypeReference(type);
         if (decl) {
@@ -127,6 +131,9 @@ export class JavaTypeNameConvertor {
             case idl.IDLDate: return 'Date';
             case idl.IDLBufferType: return 'byte[]';
             case idl.IDLInteropReturnBufferType: return 'byte[]';
+            case idl.IDLSerializerBuffer: return 'long';
+            case idl.IDLAnyType: return 'Ark_Object';
+            case idl.IDLUnknownType: return 'Ark_Object';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
@@ -154,7 +161,7 @@ export class JavaTypeNameConvertor {
             case 'KStringPtr': return 'String';
             case 'string': return 'String';
         }
-        return name;
+        return name.split(".").at(-1);
     }
 }
 class JavaIdlNodeToSolidStringConvertor extends JavaTypeNameConvertor {
@@ -178,8 +185,21 @@ export class JavaInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type) {
         switch (type) {
             case idl.IDLNumberType: return "double";
-            case idl.IDLLengthType: return "String";
             case idl.IDLBooleanType: return "boolean";
+            case idl.IDLI64Type: return "long";
+            case idl.IDLU64Type: return "long";
+            case idl.IDLI32Type: return "int";
+            case idl.IDLU32Type: return "int";
+            case idl.IDLF32Type: return "float";
+            case idl.IDLBigintType: return "long";
+            case idl.IDLSerializerBuffer: return "long";
+            case idl.IDLFunctionType: return "int";
+            case idl.IDLStringType: return "String";
+            case idl.IDLBufferType: return "byte[]";
+            case idl.IDLDate: return "long";
+            case idl.IDLVoidType: return "void";
+            case idl.IDLUndefinedType: return "long";
+            case idl.IDLPointerType: return "long"; // return PrimitiveTypesInstance.NativePointer.getText()
         }
         return super.convertPrimitiveType(type);
     }

package/build/lib/src/LanguageWriters/convertors/TSConvertors.d.ts

@@ -15,7 +15,8 @@ export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNa
     convertOptional(type: idl.IDLOptionalType): string;
     convertUnion(type: idl.IDLUnionType): string;
     convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
@@ -27,10 +28,11 @@ export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNa
 export declare class TSInteropArgConvertor implements TypeConvertor<string> {
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
     convertOptional(type: idl.IDLOptionalType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertUnion(type: idl.IDLUnionType): string;
 }

package/build/lib/src/LanguageWriters/convertors/TSConvertors.js

@@ -25,16 +25,18 @@ export class TSTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return idl.getFQName(node);
+        return idl.getQualifiedName(node, "namespace.name");
     }
     convertEnum(node) {
-        return idl.getFQName(node);
+        return idl.getQualifiedName(node, "namespace.name");
     }
     convertTypedef(node) {
         return node.name;
     }
     convertCallback(node) {
-        return node.name;
+        return idl.isSyntheticEntry(node)
+            ? this.mapCallback(node)
+            : node.name;
     }
     convertMethod(node) {
         return node.name;
@@ -72,11 +74,23 @@ export class TSTypeNameConvertor {
         }
         throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
         return type.name;
     }
+    convertTypeReferenceAsImport(type, importClause) {
+        var _a;
+        const maybeTypeArguments = ((_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) ? `<${type.typeArguments.join(', ')}>` : "";
+        let decl = this.resolver.resolveTypeReference(type);
+        if (decl)
+            return `${decl.name}${maybeTypeArguments}`;
+        return `${type.name}${maybeTypeArguments}`;
+    }
     convertTypeReference(type) {
         var _a, _b;
+        if (type.name === idl.IDLObjectType.name) {
+            return type.name;
+        }
         let decl = this.resolver.resolveTypeReference(type);
         if (decl) {
             if (idl.isSyntheticEntry(decl)) {
@@ -89,33 +103,35 @@ export class TSTypeNameConvertor {
                     return this.productType(decl, isTuple, !isTuple);
                 }
             }
+            // FIXME: isEnumMember is not TYPE!
+            if (decl && idl.isEnumMember(decl) && decl.parent) {
+                // when `interface A { field?: MyEnum.Value1 }` is generated, it is not possible
+                // to deserialize A, because there is no such type information in declaration target
+                // (can not cast MyEnum to exact MyEnum.Value1)
+                decl = decl.parent;
+            }
+            let typeSpec = type.name;
+            let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.convert(it))) !== null && _b !== void 0 ? _b : [];
+            if (typeSpec === `Optional`)
+                return `${typeArgs} | undefined`;
+            if (typeSpec === `Function`)
+                return this.mapFunctionType(typeArgs);
+            const maybeTypeArguments = !(typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) ? '' : `<${typeArgs.join(', ')}>`;
+            if (decl) {
+                const path = idl.getNamespacesPathFor(decl).map(it => it.name);
+                path.push(decl.name);
+                return `${path.join(".")}${maybeTypeArguments}`;
+            }
+            return `${type.name}${maybeTypeArguments}`;
         }
-        // FIXME: isEnumMember is not TYPE!
-        if (decl && idl.isEnumMember(decl) && decl.parent) {
-            // when `interface A { field?: MyEnum.Value1 }` is generated, it is not possible
-            // to deserialize A, because there is no such type information in declaration target
-            // (can not cast MyEnum to exact MyEnum.Value1)
-            decl = decl.parent;
-        }
-        let typeSpec = type.name;
-        let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it))) !== null && _b !== void 0 ? _b : [];
-        if (typeSpec === `Optional`)
-            return `${typeArgs} | undefined`;
-        if (typeSpec === `Function`)
-            return this.mapFunctionType(typeArgs);
-        const maybeTypeArguments = !(typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) ? '' : `<${typeArgs.join(', ')}>`;
-        if (decl) {
-            const path = idl.getNamespacesPathFor(decl).map(it => it.name);
-            path.push(decl.name);
-            return `${path.join(".")}${maybeTypeArguments}`;
-        }
-        return `${type.name}${maybeTypeArguments}`;
+        return this.convert(idl.IDLCustomObjectType);
     }
     convertTypeParameter(type) {
         return type.name;
     }
     convertPrimitiveType(type) {
         switch (type) {
+            case idl.IDLFunctionType: return 'Function';
             case idl.IDLUnknownType:
             case idl.IDLCustomObjectType: return 'unknown';
             case idl.IDLThisType: return 'this';
@@ -156,7 +172,7 @@ export class TSTypeNameConvertor {
         return idlProperty;
     }
     mapCallback(decl) {
-        const params = decl.parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}`);
+        const params = decl.parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}${it.isVariadic ? "[]" : ""}`);
         return `((${params.join(", ")}) => ${this.convert(decl.returnType)})`;
     }
     productType(decl, isTuple, includeFieldNames) {
@@ -181,7 +197,7 @@ export class TSInteropArgConvertor {
     convertContainer(type) {
         throw new Error(`Cannot pass container types through interop`);
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
         throw new Error(`Cannot pass import types through interop`);
     }
     convertOptional(type) {
@@ -192,14 +208,14 @@ export class TSInteropArgConvertor {
             case idl.IDLI64Type: return "KLong";
             case idl.IDLU64Type: return "KLong";
             case idl.IDLI32Type: return "KInt";
+            case idl.IDLU32Type: return "KInt";
             case idl.IDLF32Type: return "KFloat";
             case idl.IDLNumberType: return 'number';
             case idl.IDLBigintType: return 'bigint';
             case idl.IDLBooleanType:
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';
-            case idl.IDLBufferType: return `ArrayBuffer`;
-            case idl.IDLLengthType: return 'Length';
+            case idl.IDLBufferType: return 'ArrayBuffer';
             case idl.IDLDate: return 'number';
             case idl.IDLUndefinedType:
             case idl.IDLVoidType:
@@ -210,6 +226,9 @@ export class TSInteropArgConvertor {
     convertTypeParameter(type) {
         throw new Error("Cannot pass type parameters through interop");
     }
+    convertTypeReferenceAsImport(type, importClause) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
     convertTypeReference(type) {
         throw new Error(`Cannot pass type references through interop`);
     }

package/build/lib/src/LanguageWriters/nameConvertor.d.ts

@@ -6,13 +6,15 @@ export interface TypeConvertor<T> {
     convertOptional(type: idl.IDLOptionalType): T;
     convertUnion(type: idl.IDLUnionType): T;
     convertContainer(type: idl.IDLContainerType): T;
-    convertImport(type: idl.IDLReferenceType, importClause: string): T;
+    convertImport(type: idl.IDLImport): T;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): T;
     convertTypeReference(type: idl.IDLReferenceType): T;
     convertTypeParameter(type: idl.IDLTypeParameterType): T;
     convertPrimitiveType(type: idl.IDLPrimitiveType): T;
 }
 export declare function convertType<T>(convertor: TypeConvertor<T>, type: idl.IDLType): T;
 export interface DeclarationConvertor<T> {
+    convertImport(node: idl.IDLImport): T;
     convertNamespace(node: idl.IDLNamespace): T;
     convertInterface(node: idl.IDLInterface): T;
     convertEnum(node: idl.IDLEnum): T;

package/build/lib/src/LanguageWriters/nameConvertor.js

@@ -20,10 +20,12 @@ export function convertType(convertor, type) {
         return convertor.convertUnion(type);
     if (idl.isContainerType(type))
         return convertor.convertContainer(type);
+    if (idl.isImport(type))
+        return convertor.convertImport(type);
     if (idl.isReferenceType(type)) {
         const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
         return importAttr
-            ? convertor.convertImport(type, importAttr)
+            ? convertor.convertTypeReferenceAsImport(type, importAttr)
             : convertor.convertTypeReference(type);
     }
     if (idl.isTypeParameterType(type))
@@ -33,6 +35,8 @@ export function convertType(convertor, type) {
     throw new Error(`Unknown type ${idl.IDLKind[type.kind]}`);
 }
 export function convertDeclaration(convertor, decl) {
+    if (idl.isImport(decl))
+        return convertor.convertImport(decl);
     if (idl.isNamespace(decl))
         return convertor.convertNamespace(decl);
     if (idl.isInterface(decl))

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

@@ -80,7 +80,10 @@ export declare class CJLanguageWriter extends LanguageWriter {
         name: string;
         stringId: string | undefined;
         numberId: number;
-    }[], op: (writer: LanguageWriter) => void): void;
+    }[], options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }, op: (writer: LanguageWriter) => void): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
     writeFunctionDeclaration(name: string, signature: MethodSignature): void;
     writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
@@ -105,7 +108,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     private writeDeclaration;
     writeNativeFunctionCall(printer: LanguageWriter, name: string, signature: MethodSignature): void;
     writeNativeMethodDeclaration(method: Method): void;
-    makeEnumCast(_enumEntry: idl.IDLEnum, enumName: string): string;
+    i32FromEnum(value: LanguageExpression, _enumEntry: idl.IDLEnum): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeClassInit(type: idl.IDLType, parameters: LanguageExpression[]): LanguageExpression;
     makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
@@ -125,14 +128,14 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeDefinedCheck(value: string): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     writePrintLog(message: string): void;
-    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     getObjectAccessor(convertor: BaseArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
     makeUnwrapOptional(expression: LambdaExpression): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
-    makeRuntimeTypeGetterCall(value: string): LanguageExpression;
+    protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;
     makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
     makeNull(value?: string): LanguageExpression;
     getTagType(): idl.IDLType;
@@ -144,9 +147,11 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, convertorIndex?: number): LanguageExpression;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
     makeTupleAccess(value: string, index: number): LanguageExpression;
-    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
-    makeEnumEntity(enumEntity: idl.IDLEnum, isExport: boolean): LanguageStatement;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    makeEnumEntity(enumEntity: idl.IDLEnum, options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }): LanguageStatement;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     escapeKeyword(word: string): string;
@@ -154,7 +159,5 @@ export declare class CJLanguageWriter extends LanguageWriter {
     popNamespace(ident?: boolean): void;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
-    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
-    makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
 }
 //# sourceMappingURL=CJLanguageWriter.d.ts.map