@idlizer/core 2.0.15

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

@@ -0,0 +1,36 @@
+import * as idl from '../idl';
+import { IdlNameConvertor, NodeConvertor } from "./nameConvertor";
+import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+export interface ConvertResult {
+    text: string;
+    noPrefix: boolean;
+}
+export declare class InteropConvertor implements NodeConvertor<ConvertResult> {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    private make;
+    convertNode(node: idl.IDLNode): ConvertResult;
+    convertNamespace(node: idl.IDLNamespace): ConvertResult;
+    convertInterface(node: idl.IDLInterface): ConvertResult;
+    convertEnum(node: idl.IDLEnum): ConvertResult;
+    convertTypedef(node: idl.IDLTypedef): ConvertResult;
+    convertCallback(node: idl.IDLCallback): ConvertResult;
+    convertMethod(node: idl.IDLMethod): ConvertResult;
+    convertConstant(node: idl.IDLConstant): ConvertResult;
+    convertOptional(type: idl.IDLOptionalType): ConvertResult;
+    convertUnion(type: idl.IDLUnionType): ConvertResult;
+    convertContainer(type: idl.IDLContainerType): ConvertResult;
+    convertImport(type: idl.IDLReferenceType, _: string): ConvertResult;
+    convertTypeReference(type: idl.IDLReferenceType): ConvertResult;
+    convertTypeParameter(type: idl.IDLTypeParameterType): ConvertResult;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
+    private enumName;
+    private computeTargetTypeLiteralName;
+}
+export declare class InteropNameConvertor implements IdlNameConvertor {
+    protected resolver: ReferenceResolver;
+    private readonly interopConvertor;
+    constructor(resolver: ReferenceResolver);
+    convert(node: idl.IDLNode): string;
+}
+//# sourceMappingURL=InteropConvertor.d.ts.map

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

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2025 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 * as idl from '../idl';
+import { convertNode } from "./nameConvertor";
+import { generatorConfiguration } from '../config';
+import { capitalize } from '../util';
+import { qualifiedName } from '../peer-generation/idl/common';
+import { maybeTransformManagedCallback } from './ArgConvertors';
+export class InteropConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    make(text, noPrefix = false) {
+        return { text, noPrefix };
+    }
+    convertNode(node) {
+        return convertNode(this, node);
+    }
+    convertNamespace(node) {
+        throw new Error("Internal error: namespaces are not allowed on the interop layer");
+    }
+    convertInterface(node) {
+        switch (node.subkind) {
+            case idl.IDLInterfaceSubkind.AnonymousInterface:
+                return node.name
+                    ? this.make(node.name)
+                    : this.make(this.computeTargetTypeLiteralName(node), true);
+            case idl.IDLInterfaceSubkind.Interface:
+            case idl.IDLInterfaceSubkind.Class:
+                if (idl.hasExtAttribute(node, idl.IDLExtendedAttributes.Predefined)) {
+                    return this.make(node.name, true);
+                }
+                return this.make(node.name);
+            case idl.IDLInterfaceSubkind.Tuple:
+                return node.name
+                    ? this.make(node.name)
+                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
+        }
+    }
+    convertEnum(node) {
+        return this.make(this.enumName(node));
+    }
+    convertTypedef(node) {
+        return this.make(node.name);
+    }
+    convertCallback(node) {
+        return this.make(generatorConfiguration().param("LibraryPrefix") + node.name, true);
+    }
+    convertMethod(node) {
+        return this.make(node.name);
+    }
+    convertConstant(node) {
+        return this.make(node.name);
+    }
+    /////////////////////////////////////////////////////////////////////////////////////////
+    convertOptional(type) {
+        return this.convertNode(type.type);
+    }
+    convertUnion(type) {
+        return this.make(type.name, false);
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isPromise(type)) {
+            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`);
+        }
+        if (idl.IDLContainerUtils.isSequence(type)) {
+            if (type.elementType[0] === idl.IDLU8Type) {
+                return this.make(`uint8_t*`, true);
+            }
+            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, true);
+        }
+        if (idl.IDLContainerUtils.isRecord(type)) {
+            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, true);
+        }
+        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    convertImport(type, _) {
+        return this.make(idl.IDLCustomObjectType.name);
+    }
+    convertTypeReference(type) {
+        var _a;
+        const refName = type.name;
+        switch (refName) {
+            case "object":
+            case "Object":
+                return this.make('CustomObject');
+        }
+        if (generatorConfiguration().paramArray("knownParameterized").includes(refName)) {
+            return this.make('CustomObject');
+        }
+        let decl = this.resolver.toDeclaration(type);
+        if (idl.isCallback(decl)) {
+            decl = (_a = maybeTransformManagedCallback(decl)) !== null && _a !== void 0 ? _a : decl;
+        }
+        if (idl.isType(decl)) {
+            if (idl.isReferenceType(decl)) {
+                return this.make(`${capitalize(decl.name)}`);
+            }
+            return this.convertNode(decl);
+        }
+        let res = this.convertNode(decl);
+        if (type.name === "Optional")
+            res = this.make("Opt_" + res.text, true);
+        return res;
+    }
+    convertTypeParameter(type) {
+        return this.make('CustomObject');
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLVoidType: return this.make('void', true);
+            case idl.IDLI8Type: return this.make(`Int8`);
+            case idl.IDLU8Type: return this.make(`UInt8`);
+            case idl.IDLI16Type: return this.make(`Int16`);
+            case idl.IDLU16Type: return this.make(`UInt16`);
+            case idl.IDLI32Type: return this.make(`Int32`);
+            case idl.IDLU32Type: return this.make(`UInt32`);
+            case idl.IDLI64Type: return this.make(`Int64`);
+            case idl.IDLU64Type: return this.make(`UInt64`);
+            case idl.IDLF32Type: return this.make(`Float32`);
+            case idl.IDLF64Type: return this.make(`Float64`);
+            case idl.IDLNumberType: return this.make(`Number`);
+            case idl.IDLStringType: return this.make(`String`);
+            case idl.IDLBooleanType: return this.make(`Boolean`);
+            case idl.IDLPointerType: return this.make('NativePointer');
+            case idl.IDLUnknownType:
+            case idl.IDLCustomObjectType:
+            case idl.IDLAnyType: return this.make(`CustomObject`);
+            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');
+            case idl.IDLPointerType: return this.make('Pointer');
+        }
+        throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    enumName(target) {
+        return qualifiedName(target, "_");
+    }
+    computeTargetTypeLiteralName(decl) {
+        const map = new Map();
+        for (const prop of decl.properties) {
+            const type = this.convertNode(prop.type);
+            const values = map.has(type.text) ? map.get(type.text) : [];
+            values.push(prop.name);
+            map.set(type.text, values);
+        }
+        const names = Array.from(map.keys()).map(key => `${key}_${map.get(key).join('_')}`);
+        return `Literal_${names.join('_')}`;
+    }
+}
+export class InteropNameConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+        this.interopConvertor = new InteropConvertor(resolver);
+    }
+    convert(node) {
+        return this.interopConvertor.convertNode(node).text;
+    }
+}
+//# sourceMappingURL=InteropConvertor.js.map

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

@@ -0,0 +1,386 @@
+import { Language } from "../Language";
+import { IndentedPrinter } from "../IndentedPrinter";
+import * as idl from "../idl";
+import { stringOrNone } from "../util";
+import { NativeModuleType, RuntimeType } from "./common";
+import { ArgConvertor } from "./ArgConvertors";
+import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+export interface LanguageExpression {
+    asString(): string;
+}
+export declare class TernaryExpression implements LanguageExpression {
+    condition: LanguageExpression;
+    trueExpression: LanguageExpression;
+    falseExpression: LanguageExpression;
+    constructor(condition: LanguageExpression, trueExpression: LanguageExpression, falseExpression: LanguageExpression);
+    asString(): string;
+}
+export declare class NaryOpExpression implements LanguageExpression {
+    op: string;
+    args: LanguageExpression[];
+    constructor(op: string, args: LanguageExpression[]);
+    asString(): string;
+}
+export declare class StringExpression implements LanguageExpression {
+    value: string;
+    constructor(value: string);
+    asString(): string;
+}
+export declare class NewObjectExpression implements LanguageExpression {
+    private objectName;
+    private params;
+    constructor(objectName: string, params: LanguageExpression[]);
+    asString(): string;
+}
+export declare class FunctionCallExpression implements LanguageExpression {
+    private name;
+    private params;
+    constructor(name: string, params: LanguageExpression[]);
+    asString(): string;
+}
+export declare class MethodCallExpression extends FunctionCallExpression {
+    receiver: string;
+    nullable: boolean;
+    constructor(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean);
+    asString(): string;
+}
+export declare class FieldAccessExpression {
+    receiver: string;
+    field: string;
+    nullable: boolean;
+    constructor(receiver: string, field: string, nullable?: boolean);
+    asString(): string;
+}
+export declare class CheckDefinedExpression implements LanguageExpression {
+    private value;
+    constructor(value: string);
+    asString(): string;
+}
+export interface LanguageStatement {
+    write(writer: LanguageWriter): void;
+}
+export declare class ProxyStatement implements LanguageStatement {
+    private cb;
+    constructor(cb: (writer: LanguageWriter) => void);
+    write(writer: LanguageWriter): void;
+}
+export declare class AssignStatement implements LanguageStatement {
+    variableName: string;
+    type: idl.IDLType | undefined;
+    expression: LanguageExpression | undefined;
+    isDeclared: boolean;
+    protected isConst: boolean;
+    protected options?: MakeAssignOptions | undefined;
+    constructor(variableName: string, type: idl.IDLType | undefined, expression: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions | undefined);
+    write(writer: LanguageWriter): void;
+}
+export declare class ExpressionStatement implements LanguageStatement {
+    expression: LanguageExpression;
+    constructor(expression: LanguageExpression);
+    write(writer: LanguageWriter): void;
+}
+export declare class BlockStatement implements LanguageStatement {
+    statements: LanguageStatement[];
+    private inScope;
+    constructor(statements: LanguageStatement[], inScope?: boolean);
+    write(writer: LanguageWriter): void;
+}
+export declare class IfStatement implements LanguageStatement {
+    condition: LanguageExpression;
+    thenStatement: LanguageStatement;
+    elseStatement: LanguageStatement | undefined;
+    insideIfOp: (() => void) | undefined;
+    insideElseOp: (() => void) | undefined;
+    constructor(condition: LanguageExpression, thenStatement: LanguageStatement, elseStatement: LanguageStatement | undefined, insideIfOp: (() => void) | undefined, insideElseOp: (() => void) | undefined);
+    write(writer: LanguageWriter): void;
+    writeBody(writer: LanguageWriter, body: LanguageStatement, op: () => void): void;
+}
+export type BranchStatement = {
+    expr: LanguageExpression;
+    stmt: LanguageStatement;
+};
+export declare class MultiBranchIfStatement implements LanguageStatement {
+    private readonly statements;
+    private readonly elseStatement;
+    constructor(statements: BranchStatement[], elseStatement: LanguageStatement | undefined);
+    write(writer: LanguageWriter): void;
+}
+export declare class CheckOptionalStatement implements LanguageStatement {
+    undefinedValue: string;
+    optionalExpression: LanguageExpression;
+    doStatement: LanguageStatement;
+    constructor(undefinedValue: string, optionalExpression: LanguageExpression, doStatement: LanguageStatement);
+    write(writer: LanguageWriter): void;
+}
+export declare class TsEnumEntityStatement implements LanguageStatement {
+    private readonly enumEntity;
+    private readonly isExport;
+    constructor(enumEntity: idl.IDLEnum, isExport: boolean);
+    write(writer: LanguageWriter): void;
+    private maybeQuoted;
+}
+export declare class ReturnStatement implements LanguageStatement {
+    expression?: LanguageExpression | undefined;
+    constructor(expression?: LanguageExpression | undefined);
+    write(writer: LanguageWriter): void;
+}
+export declare abstract class LambdaExpression implements LanguageExpression {
+    private originalWriter;
+    protected signature: MethodSignature;
+    protected resolver: ReferenceResolver;
+    private body?;
+    constructor(originalWriter: LanguageWriter, signature: MethodSignature, resolver: ReferenceResolver, body?: LanguageStatement[] | undefined);
+    protected abstract get statementHasSemicolon(): boolean;
+    abstract asString(): string;
+    bodyAsString(): string;
+}
+export declare enum FieldModifier {
+    READONLY = 0,
+    PRIVATE = 1,
+    PUBLIC = 2,
+    STATIC = 3,
+    PROTECTED = 4,
+    FINAL = 5,
+    VOLATILE = 6,
+    INTERNAL = 7
+}
+export declare enum MethodModifier {
+    PUBLIC = 0,
+    PRIVATE = 1,
+    STATIC = 2,
+    NATIVE = 3,
+    INLINE = 4,
+    GETTER = 5,
+    SETTER = 6,
+    PROTECTED = 7,
+    FREE = 8
+}
+export declare enum ClassModifier {
+    PUBLIC = 0,
+    PRIVATE = 1,
+    PROTECTED = 2
+}
+export declare class Field {
+    name: string;
+    type: idl.IDLType;
+    modifiers: FieldModifier[];
+    constructor(name: string, type: idl.IDLType, modifiers?: FieldModifier[]);
+}
+export declare class Method {
+    name: string;
+    signature: MethodSignature;
+    modifiers: MethodModifier[] | undefined;
+    generics?: string[] | undefined;
+    constructor(name: string, signature: MethodSignature, modifiers?: MethodModifier[] | undefined, generics?: string[] | undefined);
+}
+export declare class PrintHint {
+    hint: string;
+    private constructor();
+    static AsPointer: PrintHint;
+    static AsConstPointer: PrintHint;
+    static AsValue: PrintHint;
+    static AsConstReference: PrintHint;
+}
+type MethodArgPrintHintOrNone = PrintHint | undefined;
+export declare class MethodSignature {
+    returnType: idl.IDLType;
+    args: idl.IDLType[];
+    defaults: stringOrNone[] | undefined;
+    printHints?: MethodArgPrintHintOrNone[] | undefined;
+    argNames?: string[] | undefined;
+    constructor(returnType: idl.IDLType, args: idl.IDLType[], defaults?: stringOrNone[] | undefined, printHints?: MethodArgPrintHintOrNone[] | undefined, argNames?: string[] | undefined);
+    argName(index: number): string;
+    argDefault(index: number): string | undefined;
+    retHint(): PrintHint | undefined;
+    argHint(index: number): PrintHint | undefined;
+    toString(): string;
+}
+export declare class NamedMethodSignature extends MethodSignature {
+    argsNames: string[];
+    constructor(returnType: idl.IDLType, args?: idl.IDLType[], argsNames?: string[], defaults?: stringOrNone[] | undefined, printHints?: MethodArgPrintHintOrNone[]);
+    static make(returnType: idl.IDLType, args: {
+        name: string;
+        type: idl.IDLType;
+    }[]): NamedMethodSignature;
+    argName(index: number): string;
+}
+export interface ObjectArgs {
+    [name: string]: string;
+}
+export interface PrinterLike {
+    getOutput(): string[];
+}
+export declare abstract class LanguageWriter {
+    printer: IndentedPrinter;
+    protected resolver: ReferenceResolver;
+    language: Language;
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, language: Language);
+    indentDepth(): number;
+    maybeSemicolon(): string;
+    abstract writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
+    abstract writeEnum(name: string, members: {
+        name: string;
+        alias?: string;
+        stringId: string | undefined;
+        numberId: number;
+    }[], op?: (writer: this) => void): void;
+    abstract writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], isDeclared?: boolean): void;
+    abstract writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
+    abstract writeFunctionDeclaration(name: string, signature: MethodSignature): void;
+    abstract writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
+    abstract writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
+    abstract writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
+    abstract writeMethodImplementation(method: Method, op: (writer: this) => void): void;
+    abstract writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
+    abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
+    abstract makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
+    abstract makeThrowError(message: string): LanguageStatement;
+    abstract makeReturn(expr?: LanguageExpression): LanguageStatement;
+    abstract makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
+    abstract makeRuntimeType(rt: RuntimeType): LanguageExpression;
+    abstract getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
+    abstract makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    abstract writePrintLog(message: string): void;
+    abstract makeUndefined(): LanguageExpression;
+    makeUnwrapOptional(expression: LanguageExpression): LanguageExpression;
+    abstract makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
+    abstract makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
+    abstract makeMapInit(type: idl.IDLType): LanguageExpression;
+    abstract makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
+    abstract makeLoop(counter: string, limit: string): LanguageStatement;
+    abstract makeLoop(counter: string, limit: string, statement: LanguageStatement): LanguageStatement;
+    abstract makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    abstract getTagType(): idl.IDLType;
+    abstract getRuntimeType(): idl.IDLType;
+    abstract makeTupleAssign(receiver: string, tupleFields: string[]): LanguageStatement;
+    abstract get supportedModifiers(): MethodModifier[];
+    abstract get supportedFieldModifiers(): FieldModifier[];
+    abstract enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
+    abstract ordinalFromEnum(value: LanguageExpression, enumReference: idl.IDLType): LanguageExpression;
+    abstract makeEnumCast(enumName: string, unsafe: boolean, convertor: ArgConvertor | undefined): string;
+    abstract getNodeName(type: idl.IDLNode): string;
+    abstract fork(options?: {
+        resolver?: ReferenceResolver;
+    }): LanguageWriter;
+    concat(other: PrinterLike): this;
+    printTo(file: string): void;
+    writeLines(lines: string): void;
+    writeGetterImplementation(method: Method, op: (writer: this) => void): void;
+    writeSetterImplementation(method: Method, op: (writer: this) => void): void;
+    writeSuperCall(params: string[]): void;
+    writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
+    writeStatement(stmt: LanguageStatement): void;
+    writeStatements(...statements: LanguageStatement[]): void;
+    writeExpressionStatement(smth: LanguageExpression): void;
+    makeRef(type: idl.IDLType, _options?: MakeRefOptions): idl.IDLType;
+    makeThis(): LanguageExpression;
+    makeNull(value?: string): LanguageExpression;
+    makeVoid(): LanguageExpression;
+    makeRuntimeTypeCondition(typeVarName: string, equals: boolean, type: RuntimeType, varName?: string): LanguageExpression;
+    makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
+    makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
+    makeFunctionCall(name: string | LanguageExpression, params: LanguageExpression[]): LanguageExpression;
+    makeMethodCall(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
+    makeFieldAccess(receiver: string, method: string, nullable?: boolean): LanguageExpression;
+    makeNativeCall(nativeModule: NativeModuleType, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
+    makeBlock(statements: LanguageStatement[], inScope?: boolean): BlockStatement;
+    nativeReceiver(nativeModule: NativeModuleType): string;
+    makeDefinedCheck(value: string): LanguageExpression;
+    makeRuntimeTypeDefinedCheck(runtimeType: string): LanguageExpression;
+    makeCondition(condition: LanguageExpression, thenStatement: LanguageStatement, elseStatement?: LanguageStatement, insideIfOp?: () => void, insideElseOp?: () => void): LanguageStatement;
+    makeMultiBranchCondition(conditions: BranchStatement[], elseStatement?: LanguageStatement): LanguageStatement;
+    makeTernary(condition: LanguageExpression, trueExpression: LanguageExpression, falseExpression: LanguageExpression): LanguageExpression;
+    makeArrayLength(array: string, length?: string): LanguageExpression;
+    makeArrayAccess(value: string, indexVar: string): LanguageExpression;
+    makeTupleAccess(value: string, index: number): LanguageExpression;
+    makeUnionSelector(value: string, valueType: string): LanguageStatement;
+    makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, _convertorIndex?: number, _runtimeTypeIndex?: number): LanguageExpression;
+    makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index?: number): LanguageExpression;
+    makeUnionTypeDefaultInitializer(): LanguageExpression;
+    makeRuntimeTypeGetterCall(value: string): LanguageExpression;
+    makeArrayResize(array: string, arrayType: string, length: string, deserializer: string): LanguageStatement;
+    makeMapResize(mapTypeName: string, keyType: idl.IDLType, valueType: idl.IDLType, map: string, size: string, deserializer: string): LanguageStatement;
+    makeMapSize(map: string): LanguageExpression;
+    makeTupleAlloc(option: string): LanguageStatement;
+    makeSetUnionSelector(value: string, index: string): LanguageStatement;
+    makeSetOptionTag(value: string, tag: LanguageExpression): LanguageStatement;
+    makeString(value: string): LanguageExpression;
+    makeNaryOp(op: string, args: LanguageExpression[]): LanguageExpression;
+    makeStatement(expr: LanguageExpression): LanguageStatement;
+    writeNativeMethodDeclaration(name: string, signature: MethodSignature, isNative?: boolean): void;
+    writeUnsafeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
+    pushIndent(): void;
+    popIndent(): void;
+    print(string: stringOrNone): void;
+    getOutput(): string[];
+    makeSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): MethodSignature;
+    makeNamedSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): NamedMethodSignature;
+    makeNativeMethodNamedSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): NamedMethodSignature;
+    makeSerializerConstructorSignature(): NamedMethodSignature | undefined;
+    mapFieldModifier(modifier: FieldModifier): string;
+    mapMethodModifier(modifier: MethodModifier): string;
+    /**
+     * TODO: replace me with {@link makeUnsafeCast_}
+     */
+    makeUnsafeCast(convertor: ArgConvertor, param: string): string;
+    makeUnsafeCast_(value: LanguageExpression, type: idl.IDLType, typeOptions?: PrintHint): string;
+    runtimeType(param: ArgConvertor, valueType: string, value: string): void;
+    makeDiscriminatorFromFields(convertor: {
+        targetType: (writer: LanguageWriter) => string;
+    }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
+    makeCallIsResource(value: string): LanguageExpression;
+    makeEnumEntity(enumEntity: idl.IDLEnum, isExport: boolean): LanguageStatement;
+    makeFieldModifiersList(modifiers: FieldModifier[] | undefined, customFieldFilter?: (field: FieldModifier) => boolean): string;
+    escapeKeyword(keyword: string): string;
+    makeCastCustomObject(customName: string, _isGenericType: boolean): LanguageExpression;
+    makeHasOwnProperty(value: string, _valueTypeName: string, property: string, propertyTypeName?: string): LanguageExpression;
+    discriminatorFromExpressions(value: string, runtimeType: RuntimeType, exprs: LanguageExpression[]): LanguageExpression;
+    makeDiscriminatorConvertor(_convertor: ArgConvertor, _value: string, _index: number): LanguageExpression | undefined;
+    makeNot(expr: LanguageExpression): LanguageExpression;
+    makeEquals(args: LanguageExpression[]): LanguageExpression;
+    castToInt(value: string, bitness: 8 | 32): string;
+    castToBoolean(value: string): string;
+    makeCallIsObject(value: string): LanguageExpression;
+    makeCallIsArrayBuffer(value: string): LanguageExpression;
+    instanceOf(convertor: ArgConvertor, value: string, _duplicateMembers?: Set<string>): LanguageExpression;
+    typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
+    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
+    makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
+    stringifyTypeOrEmpty(type: idl.IDLType | undefined): string;
+    /**
+     * Writes `namespace <namespace> {` and adds extra indent
+     * @param namespace Namespace to begin
+     */
+    pushNamespace(namespace: string, ident?: boolean): void;
+    /**
+     * Writes closing brace of namespace block and removes one level of indent
+     */
+    popNamespace(ident?: boolean): void;
+}
+export declare function mangleMethodName(method: Method, id?: number): string;
+export declare function printMethodDeclaration(printer: IndentedPrinter, retType: string, methodName: string, apiParameters: string[], postfix?: string): void;
+export declare function copyMethod(method: Method, overrides: {
+    name?: string;
+    signature?: MethodSignature;
+    modifiers?: MethodModifier[];
+    generics?: string[];
+}): Method;
+export type MakeCastOptions = {
+    unsafe?: boolean;
+    optional?: boolean;
+    receiver?: string;
+    toRef?: boolean;
+    overrideTypeName?: string;
+};
+export type MakeRefOptions = {
+    receiver?: string;
+};
+export type MakeAssignOptions = {
+    receiver?: string;
+    assignRef?: boolean;
+    overrideTypeName?: string;
+};
+export type ExpressionAssigner = (expression: LanguageExpression) => LanguageStatement;
+export {};
+//# sourceMappingURL=LanguageWriter.d.ts.map