@idlizer/core 2.0.15

package/build/lib/src/peer-generation/ReferenceResolver.js

@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+export function createEmptyReferenceResolver() {
+    return {
+        resolveTypeReference() {
+            return undefined;
+        },
+        toDeclaration(type) {
+            return type;
+        }
+    };
+}
+/** Please do not store any global instances */
+export function createAlternativeReferenceResolver(mainResolver, alternatives) {
+    return {
+        resolveTypeReference(type, pointOfView, rootEntries) {
+            var _a;
+            return (_a = mainResolver.resolveTypeReference(type, pointOfView, rootEntries)) !== null && _a !== void 0 ? _a : alternatives.get(type.name);
+        },
+        toDeclaration(type) {
+            return mainResolver.toDeclaration(type);
+        },
+    };
+}
+//# sourceMappingURL=ReferenceResolver.js.map

package/build/lib/src/peer-generation/idl/IdlNameConvertor.d.ts

@@ -0,0 +1,28 @@
+import * as idl from "../../idl";
+import { DeclarationConvertor } from "../../LanguageWriters/nameConvertor";
+import { Language } from "../../Language";
+export declare class DeclarationNameConvertor implements DeclarationConvertor<string> {
+    convertInterface(decl: idl.IDLInterface): string;
+    convertEnum(decl: idl.IDLEnum): string;
+    convertTypedef(decl: idl.IDLTypedef): string;
+    convertCallback(decl: idl.IDLCallback): string;
+    convertNamespace(node: idl.IDLNamespace): string;
+    convertMethod(node: idl.IDLMethod): string;
+    convertConstant(node: idl.IDLConstant): string;
+    static readonly I: DeclarationNameConvertor;
+}
+export declare class TSFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl: idl.IDLEnum): string;
+    static readonly I: TSFeatureNameConvertor;
+}
+export declare class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl: idl.IDLEnum): string;
+    static readonly I: ETSDeclarationNameConvertor;
+}
+export declare class ETSFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl: idl.IDLEnum): string;
+    static readonly I: ETSFeatureNameConvertor;
+}
+export declare function createDeclarationNameConvertor(language: Language): DeclarationNameConvertor;
+export declare function createFeatureNameConvertor(language: Language): DeclarationNameConvertor;
+//# sourceMappingURL=IdlNameConvertor.d.ts.map

package/build/lib/src/peer-generation/idl/IdlNameConvertor.js

@@ -0,0 +1,82 @@
+/*
+ * 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 * as idl from "../../idl";
+import { Language } from "../../Language";
+export class DeclarationNameConvertor {
+    convertInterface(decl) {
+        return decl.name;
+    }
+    convertEnum(decl) {
+        return `${idl.getNamespacesPathFor(decl).join('')}${decl.name}`;
+    }
+    convertTypedef(decl) {
+        return decl.name;
+    }
+    convertCallback(decl) {
+        var _a;
+        return (_a = decl.name) !== null && _a !== void 0 ? _a : "MISSING CALLBACK NAME";
+    }
+    convertNamespace(node) {
+        return node.name;
+    }
+    convertMethod(node) {
+        return node.name;
+    }
+    convertConstant(node) {
+        return node.name;
+    }
+}
+DeclarationNameConvertor.I = new DeclarationNameConvertor();
+export class TSFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        return `${idl.getNamespacesPathFor(decl).join('')}${decl.name}`;
+    }
+}
+TSFeatureNameConvertor.I = new TSFeatureNameConvertor();
+export class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        const namespace = idl.getNamespacesPathFor(decl).map(it => it.name).join('_');
+        return `${namespace ? `${namespace}_` : ``}${decl.name}`;
+    }
+}
+ETSDeclarationNameConvertor.I = new ETSDeclarationNameConvertor();
+export class ETSFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        const namespace = idl.getNamespacesPathFor(decl).join('');
+        return `${namespace ? `${namespace}_` : ``}${decl.name}`;
+    }
+}
+ETSFeatureNameConvertor.I = new ETSFeatureNameConvertor();
+export function createDeclarationNameConvertor(language) {
+    switch (language) {
+        case Language.ARKTS: return ETSDeclarationNameConvertor.I;
+        case Language.JAVA:
+        case Language.CPP:
+        case Language.CJ:
+        case Language.TS: return DeclarationNameConvertor.I;
+        default: throw new Error(`Language ${language.toString()} is not supported`);
+    }
+}
+export function createFeatureNameConvertor(language) {
+    switch (language) {
+        case Language.ARKTS: return ETSFeatureNameConvertor.I;
+        case Language.JAVA:
+        case Language.CPP:
+        case Language.CJ:
+        case Language.TS: return TSFeatureNameConvertor.I;
+        default: throw new Error(`Language ${language.toString()} is not supported`);
+    }
+}
+//# sourceMappingURL=IdlNameConvertor.js.map

package/build/lib/src/peer-generation/idl/common.d.ts

@@ -0,0 +1,9 @@
+import * as idl from "../../idl";
+import { Language } from "../../Language";
+export declare function generateSyntheticIdlNodeName(type: idl.IDLType): string;
+export declare function qualifiedName(decl: idl.IDLNode, languageOrDelimiter: Language | string): string;
+export declare function typeOrUnion(types: idl.IDLType[], name?: string): idl.IDLType;
+export declare function generifiedTypeName(refType: idl.IDLReferenceType | undefined, refName?: string): string | undefined;
+export declare function generateSyntheticUnionName(types: idl.IDLType[]): string;
+export declare function isImportAttr(decl: idl.IDLNode): boolean;
+//# sourceMappingURL=common.d.ts.map

package/build/lib/src/peer-generation/idl/common.js

@@ -0,0 +1,70 @@
+/*
+ * 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 * as idl from "../../idl";
+import { Language } from "../../Language";
+import { capitalize } from "../../util";
+export function generateSyntheticIdlNodeName(type) {
+    if (idl.isPrimitiveType(type))
+        return capitalize(type.name);
+    if (idl.isContainerType(type)) {
+        const typeArgs = type.elementType.map(it => generateSyntheticIdlNodeName(it)).join("_");
+        switch (type.containerKind) {
+            case "sequence": return "Array_" + typeArgs;
+            case "record": return "Map_" + typeArgs;
+            case "Promise": return "Promise_" + typeArgs;
+            default: throw new Error(`Unknown container type ${idl.DebugUtils.debugPrintType(type)}`);
+        }
+    }
+    if (idl.isNamedNode(type))
+        return type.name;
+    if (idl.isOptionalType(type))
+        return `Opt_${generateSyntheticIdlNodeName(type.type)}`;
+    throw `Can not compute type name of ${idl.IDLKind[type.kind]}`;
+}
+export function qualifiedName(decl, languageOrDelimiter) {
+    if (!idl.isNamedNode(decl))
+        throw new Error("internal error, name required for no-named node");
+    const delimiter = typeof languageOrDelimiter === "string"
+        ? languageOrDelimiter
+        : (languageOrDelimiter === Language.CPP ? '_' : '.');
+    if (idl.isEntry(decl) && decl.namespace)
+        return qualifiedName(decl.namespace, delimiter) + delimiter + idl.forceAsNamedNode(decl).name;
+    return idl.forceAsNamedNode(decl).name;
+}
+export function typeOrUnion(types, name) {
+    const seenNames = new Set();
+    const uniqueTypes = types.filter(it => {
+        const typeName = idl.printType(it);
+        if (seenNames.has(typeName))
+            return false;
+        seenNames.add(typeName);
+        return true;
+    });
+    return uniqueTypes.length === 1 ? uniqueTypes[0] : idl.createUnionType(uniqueTypes, name);
+}
+export function generifiedTypeName(refType, refName) {
+    var _a;
+    if (!refType)
+        return undefined;
+    const typeArgs = (_a = refType.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it)).join(",");
+    return `${refName ? refName : refType.name}${typeArgs ? `<${typeArgs}>` : ``}`;
+}
+export function generateSyntheticUnionName(types) {
+    return `Union_${types.map(it => generateSyntheticIdlNodeName(it)).join("_")}`;
+}
+export function isImportAttr(decl) {
+    return idl.hasExtAttribute(decl, idl.IDLExtendedAttributes.Import);
+}
+//# sourceMappingURL=common.js.map

package/build/lib/src/peer-generation/unions.d.ts

@@ -0,0 +1,29 @@
+import { TypeConvertor } from "../LanguageWriters";
+import { IDLContainerType, IDLOptionalType, IDLPrimitiveType, IDLReferenceType, IDLType, IDLTypeParameterType, IDLUnionType } from '../idl';
+import { LanguageExpression, LanguageWriter } from "../LanguageWriters/LanguageWriter";
+import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
+import { LibraryInterface } from "../LibraryInterface";
+import { ReferenceResolver } from "./ReferenceResolver";
+export declare class UnionFlattener implements TypeConvertor<IDLType[]> {
+    private resolver;
+    constructor(resolver: ReferenceResolver);
+    convertUnion(type: IDLUnionType): IDLType[];
+    convertTypeReference(type: IDLReferenceType): IDLType[];
+    convertOptional(type: IDLOptionalType): IDLType[];
+    convertContainer(type: IDLContainerType): IDLType[];
+    convertImport(type: IDLReferenceType, importClause: string): IDLType[];
+    convertPrimitiveType(type: IDLPrimitiveType): IDLType[];
+    convertTypeParameter(type: IDLTypeParameterType): IDLType[];
+}
+export declare class UnionRuntimeTypeChecker {
+    private convertors;
+    private conflictingConvertors;
+    private duplicateMembers;
+    private discriminators;
+    constructor(convertors: ArgConvertor[]);
+    private checkConflicts;
+    makeDiscriminator(value: string, convertorIndex: number, writer: LanguageWriter): LanguageExpression;
+    reportConflicts(context: string | undefined): void;
+}
+export declare function flattenUnionType(library: LibraryInterface, type: IDLType): IDLType;
+//# sourceMappingURL=unions.d.ts.map

package/build/lib/src/peer-generation/unions.js

@@ -0,0 +1,111 @@
+/*
+ * 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 { convertType } from "../LanguageWriters";
+import { IDLCustomObjectType, IDLUndefinedType, isType, isUnionType } from '../idl';
+import { typeOrUnion } from "./idl/common";
+import { RuntimeType } from "../LanguageWriters/common";
+export class UnionFlattener {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    convertUnion(type) {
+        return type.types.flatMap(it => convertType(this, it));
+    }
+    convertTypeReference(type) {
+        const decl = this.resolver.toDeclaration(type);
+        return isType(decl) && decl !== IDLCustomObjectType ? convertType(this, decl) : [type];
+    }
+    convertOptional(type) {
+        return [type.type, IDLUndefinedType];
+    }
+    convertContainer(type) {
+        return [type];
+    }
+    convertImport(type, importClause) {
+        return [type];
+    }
+    convertPrimitiveType(type) {
+        return [type];
+    }
+    convertTypeParameter(type) {
+        return [type];
+    }
+}
+export class UnionRuntimeTypeChecker {
+    constructor(convertors) {
+        this.convertors = convertors;
+        this.conflictingConvertors = new Set();
+        this.duplicateMembers = new Set();
+        this.discriminators = [];
+        this.checkConflicts();
+    }
+    checkConflicts() {
+        const runtimeTypeConflicts = new Map();
+        this.convertors.forEach(conv => {
+            conv.runtimeTypes.forEach(rtType => {
+                const convertors = runtimeTypeConflicts.get(rtType);
+                if (convertors)
+                    convertors.push(conv);
+                else
+                    runtimeTypeConflicts.set(rtType, [conv]);
+            });
+        });
+        runtimeTypeConflicts.forEach((convertors, rtType) => {
+            if (convertors.length > 1) {
+                const allMembers = new Set();
+                if (rtType === RuntimeType.OBJECT) {
+                    convertors.forEach(convertor => {
+                        convertor.getMembers().forEach(member => {
+                            if (allMembers.has(member))
+                                this.duplicateMembers.add(member);
+                            allMembers.add(member);
+                        });
+                    });
+                }
+                convertors.forEach(convertor => {
+                    this.conflictingConvertors.add(convertor);
+                });
+            }
+        });
+    }
+    makeDiscriminator(value, convertorIndex, writer) {
+        const convertor = this.convertors[convertorIndex];
+        if (this.conflictingConvertors.has(convertor) && writer.language.needsUnionDiscrimination) {
+            const discriminator = convertor.unionDiscriminator(value, convertorIndex, writer, this.duplicateMembers);
+            this.discriminators.push([discriminator, convertor, convertorIndex]);
+            if (discriminator)
+                return discriminator;
+        }
+        return writer.makeNaryOp("||", convertor.runtimeTypes.map((it, runtimeTypeIndex) => writer.makeNaryOp("==", [
+            writer.makeUnionVariantCondition(convertor, value, `${value}_type`, RuntimeType[it], convertorIndex, runtimeTypeIndex)
+        ])));
+    }
+    reportConflicts(context) {
+        if (this.discriminators.filter(([discriminator, _, __]) => discriminator === undefined).length > 1) {
+            this.discriminators.forEach(([discr, conv, n]) => console.log(`   ${n} : ${conv.constructor.name} : ${discr ? discr.asString() : "<undefined>"}`));
+            throw new Error(`runtime type conflict in \`${context}\``);
+        }
+    }
+}
+export function flattenUnionType(library, type) {
+    const unionFlattener = new UnionFlattener(library);
+    if (isUnionType(type)) {
+        const allTypes = type.types.flatMap(it => convertType(unionFlattener, it));
+        const uniqueTypes = new Set(allTypes);
+        return uniqueTypes.size === allTypes.length ? type : typeOrUnion(Array.from(uniqueTypes));
+    }
+    return type;
+}
+//# sourceMappingURL=unions.js.map

package/build/lib/src/rand_utils.d.ts

@@ -0,0 +1,6 @@
+export declare function initRNG(): void;
+export declare function randInt(max: number, min?: number): number;
+export declare function randString(max: number): string;
+export declare function pick<K, V>(keys: K[], gen: (key: K) => string[], pickedNumbers?: number): string[];
+export declare function pickArray<T>(values: T[], maxLen?: number, pickedNumbers?: number): string[];
+//# sourceMappingURL=rand_utils.d.ts.map

package/build/lib/src/rand_utils.js

@@ -0,0 +1,100 @@
+/*
+ * 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.
+ */
+let rand = undefined;
+const MASK = 0x7FFFFFFF;
+export function initRNG() {
+    let seed;
+    console.log(`Use  IDLIZE_SEED env variable to set a seed value.`);
+    console.log(`Set  IDLIZE_SEED env variable to RANDOM to use a random seed value.`);
+    console.log(`IDLIZE_SEED=${process.env.IDLIZE_SEED}`);
+    if (process.env.IDLIZE_SEED === undefined) {
+        seed = 29;
+        console.log(`Env IDLIZE_SEED variable is not.`);
+        console.log(`Use predefined seed: ${seed}.`);
+    }
+    else if (process.env.IDLIZE_SEED == "RANDOM") {
+        seed = Math.floor(Math.random() * 4096);
+        console.log(`Use random seed: ${seed}`);
+    }
+    else {
+        seed = Number(process.env.IDLIZE_SEED);
+        console.log(`Use seed: ${seed}`);
+    }
+    rand = new XorRand(seed);
+}
+class XorRand {
+    constructor(seed) {
+        this.seed = seed;
+    }
+    random() {
+        let x = this.seed;
+        x ^= (x << 13) & MASK;
+        x ^= (x >> 17) & MASK;
+        x ^= (x << 5) & MASK;
+        this.seed = x;
+        return x / MASK;
+    }
+}
+export function randInt(max, min = 0) {
+    return Math.floor(rand.random() * (max - min)) + min;
+}
+function randChar(minChar, range) {
+    return String.fromCharCode(minChar.charCodeAt(0) + randInt(range));
+}
+export function randString(max) {
+    let array = [];
+    for (let i = 0; i < max; i++) {
+        const range = randInt(3);
+        let c = (range == 0)
+            ? randChar('0', 10)
+            : (range == 1)
+                ? randChar('a', 26)
+                : randChar('A', 26);
+        array.push(c);
+    }
+    return array.join('');
+}
+export function pick(keys, gen, pickedNumbers = 3) {
+    let values = keys.map(it => gen(it));
+    let picked = [];
+    if (values.map(it => it.length).some(it => it == 0)) {
+        console.log("Empty arguments!");
+        return [];
+    }
+    for (let _ = 0; _ < pickedNumbers; _++) {
+        let v = [];
+        for (let i = 0; i < values.length; i++) {
+            let len = values[i].length;
+            let index = randInt(len);
+            let elem = values[i][index];
+            v.push(elem);
+        }
+        picked.push(v.join(", "));
+    }
+    return [...new Set(picked)];
+}
+export function pickArray(values, maxLen = 7, pickedNumbers = 3) {
+    let picked = ["[]"];
+    for (let _ = 0; _ < pickedNumbers; _++) {
+        let len = randInt(maxLen);
+        let p = [];
+        for (let i = 0; i < len; i++) {
+            p.push(values[randInt(values.length)]);
+        }
+        picked.push(`[${p.join(", ")}]`);
+    }
+    return [...new Set(picked)];
+}
+//# sourceMappingURL=rand_utils.js.map

package/build/lib/src/util.d.ts

@@ -0,0 +1,75 @@
+import * as ts from "typescript";
+import { Language } from './Language';
+export interface NameWithType {
+    name?: ts.DeclarationName;
+    type?: ts.TypeNode;
+}
+/** True if this is visible outside this file, false otherwise */
+export declare function isNodePublic(node: ts.Node): boolean;
+export declare function nameOrNull(name: ts.EntityName | ts.DeclarationName | undefined): string | undefined;
+export declare function isNamedDeclaration(node: ts.Node): node is ts.NamedDeclaration;
+export declare function asString(node: ts.Node | undefined): string;
+export declare function arrayAt<T>(array: T[] | undefined, index: number): T | undefined;
+export declare function getComment(sourceFile: ts.SourceFile, node: ts.Node): string;
+export declare function getSymbolByNode(typechecker: ts.TypeChecker, node: ts.Node): ts.Symbol | undefined;
+export declare function getDeclarationsByNode(typechecker: ts.TypeChecker, node: ts.Node): ts.Declaration[];
+export declare function findRealDeclarations(typechecker: ts.TypeChecker, node: ts.Node): ts.Declaration[];
+export declare function getExportedDeclarationNameByDecl(declaration: ts.NamedDeclaration): string | undefined;
+export declare function getExportedDeclarationNameByNode(typechecker: ts.TypeChecker, node: ts.Node): string | undefined;
+export declare function isReadonly(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
+export declare function isExport(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
+export declare function isAbstract(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
+export declare function isStatic(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
+export declare function isAsync(modifierLikes: ts.NodeArray<ts.ModifierLike> | readonly ts.Modifier[] | undefined): boolean;
+export declare function isPrivate(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
+export declare function isProtected(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
+export declare function getLineNumberString(sourceFile: ts.SourceFile, position: number): string;
+export declare function isDefined<T>(value: T | null | undefined): value is T;
+export declare function capitalize(string: string): string;
+export declare function capitalizeConstantName(string: string): string;
+export declare function dropLast(text: string, chars: number): string;
+export declare function dropSuffix(text: string, suffix: string): string;
+export type stringOrNone = string | undefined;
+export declare function toSet(option: string | undefined): Set<string>;
+export declare function getOrPut<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V;
+export declare function indentedBy(input: string, indentedBy: number): string;
+export declare function typeOrUndefined(type: ts.TypeNode): ts.TypeNode;
+export declare function forEachExpanding<T>(array: T[], action: (element: T) => void): void;
+export declare function isTypeParamSuitableType(type: ts.TypeNode): boolean;
+export declare function heritageTypes(typechecker: ts.TypeChecker, clause: ts.HeritageClause): ts.TypeReferenceNode[];
+export declare function heritageDeclarations(typechecker: ts.TypeChecker, clause: ts.HeritageClause): ts.NamedDeclaration[];
+export declare function typeName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): string | undefined;
+export declare function typeEntityName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): ts.EntityName | undefined;
+export declare function zip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
+export declare function identNameWithNamespace(node: ts.Node, language: Language): string;
+export declare function identName(node: ts.Node | undefined): string | undefined;
+export declare function identString(node: ts.Identifier | ts.PrivateIdentifier | ts.StringLiteral | ts.QualifiedName | ts.NumericLiteral | ts.ComputedPropertyName | ts.BindingName | undefined): string | undefined;
+export declare const defaultCompilerOptions: ts.CompilerOptions;
+export declare function serializerBaseMethods(): string[];
+export declare function getNameWithoutQualifiersRight(node: ts.EntityName | undefined): string | undefined;
+export declare function getNameWithoutQualifiersLeft(node: ts.EntityName | undefined): string | undefined;
+export declare function snakeCaseToCamelCase(input: string, tailToLowerCase?: boolean): string;
+export declare function toCamelCase(input: string): string;
+export declare function isUpperCase(s: string): boolean;
+export declare function camelCaseToUpperSnakeCase(input: string): string;
+export declare function renameDtsToPeer(fileName: string, language: Language, withFileExtension?: boolean): string;
+export declare function renameDtsToComponent(fileName: string, language: Language, withFileExtension?: boolean): string;
+export declare function renameDtsToInterfaces(fileName: string, language: Language, withFileExtension?: boolean): string;
+export declare function renameClassToBuilderClass(className: string, language: Language, withFileExtension?: boolean): string;
+export declare function renameClassToMaterialized(className: string, language: Language, withFileExtension?: boolean): string;
+export declare function importTypeName(type: ts.ImportTypeNode, asType?: boolean): string;
+export declare function throwException(message: string): never;
+export declare function className(node: ts.ClassDeclaration | ts.InterfaceDeclaration): string;
+/**
+ * Add a prefix to an enum value which camel case name coincidence
+ * with the the same upper case name for an another enum value
+ */
+export declare function nameEnumValues(enumTarget: ts.EnumDeclaration): string[];
+export declare function groupBy<K, V>(values: V[], selector: (value: V) => K): Map<K, V[]>;
+export declare function removeExt(filename: string): string;
+export declare function warn(message: string): void;
+export declare function hashCodeFromString(value: string): number;
+export declare function forceWriteFile(filePath: string, content: string): void;
+export declare function findVersion(): any;
+export declare function zipMany<T>(...xs: T[][]): Array<Array<T | undefined>>;
+//# sourceMappingURL=util.d.ts.map