@vkontakte/api-schema-typescript-generator 0.15.0 → 0.17.0

package/dist/constants.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.baseAPIParamsInterfaceName = exports.basePropertyExistsRef = exports.baseOkResponseRef = exports.baseBoolIntRef = exports.newLineChar = exports.tabChar = exports.spaceChar = exports.primitiveTypes = exports.scalarTypes = exports.PropertyType = exports.DEFAULT_API_VERSION = void 0;
 const os_1 = require("os");
-exports.DEFAULT_API_VERSION = '5.130';
+exports.DEFAULT_API_VERSION = '5.131';
 exports.PropertyType = {
     INTEGER: 'integer',
     BOOLEAN: 'boolean',

package/dist/generator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportsBlock = void 0;
+exports.generateImportsBlock = generateImportsBlock;
 const constants_1 = require("./constants");
 const helpers_1 = require("./helpers");
 const types_1 = require("./types");
@@ -9,11 +9,11 @@ function generateImportsBlock(refs, section, type) {
     let importRefs = Object.entries(refs)
         .filter(([, type]) => type === types_1.RefsDictionaryType.GenerateAndImport)
         .map(([key]) => key);
-    importRefs = utils_1.uniqueArray(importRefs);
+    importRefs = (0, utils_1.uniqueArray)(importRefs);
     const paths = {};
     importRefs.forEach((objectName) => {
-        const importSection = helpers_1.getSectionFromObjectName(objectName);
-        const interfaceName = helpers_1.getInterfaceName(objectName);
+        const importSection = (0, helpers_1.getSectionFromObjectName)(objectName);
+        const interfaceName = (0, helpers_1.getInterfaceName)(objectName);
         let path;
         if (type === types_1.ObjectType.Object) {
             if (section === importSection) {
@@ -32,10 +32,9 @@ function generateImportsBlock(refs, section, type) {
         paths[path].push(interfaceName);
     });
     const importLines = [];
-    utils_1.sortArrayAlphabetically(Object.keys(paths)).forEach((path) => {
-        const interfaces = utils_1.sortArrayAlphabetically(paths[path]).join(', ');
+    (0, utils_1.sortArrayAlphabetically)(Object.keys(paths)).forEach((path) => {
+        const interfaces = (0, utils_1.sortArrayAlphabetically)(paths[path]).join(', ');
         importLines.push(`import { ${interfaces} } from '${path}';`);
     });
     return importLines.join(constants_1.newLineChar);
 }
-exports.generateImportsBlock = generateImportsBlock;

package/dist/generators/APITypingsGenerator.js

@@ -17,11 +17,12 @@ const CommentCodeBlock_1 = require("./CommentCodeBlock");
 const log_1 = require("../log");
 const generator_1 = require("../generator");
 const typeString_1 = require("./typeString");
+const mergeImports_1 = require("./utils/mergeImports");
 class APITypingsGenerator {
     constructor(options) {
         this.needEmit = options.needEmit;
         this.outDirPath = options.outDirPath;
-        this.methodsPattern = helpers_1.prepareMethodsPattern(options.methodsPattern);
+        this.methodsPattern = (0, helpers_1.prepareMethodsPattern)(options.methodsPattern);
         this.methodsDefinitions = options.methodsDefinitions;
         this.methodsList = options.methodsDefinitions.methods || [];
         this.objects = this.convertJSONSchemaDictionary(options.objects);
@@ -78,10 +79,7 @@ class APITypingsGenerator {
             codeBlocks: [],
         };
         this.methodFilesMap[section] = {
-            imports: {
-                ...methodFile.imports,
-                ...imports,
-            },
+            imports: (0, mergeImports_1.mergeImports)(methodFile.imports, imports),
             codeBlocks: [...methodFile.codeBlocks, ...codeBlocks],
         };
     }
@@ -102,7 +100,7 @@ class APITypingsGenerator {
                     allOfItem = tempAllOfItem;
                 }
                 else {
-                    log_1.consoleLogErrorAndExit(`${refName} ref not found`);
+                    (0, log_1.consoleLogErrorAndExit)(`${refName} ref not found`);
                 }
             }
             if (allOfItem.allOf) {
@@ -118,7 +116,7 @@ class APITypingsGenerator {
         let properties = object.properties || [];
         if (object.allOf) {
             this.collectAllOf(object).forEach((allOfItem) => {
-                object.required = utils_1.uniqueArray([...object.required, ...allOfItem.required]);
+                object.required = (0, utils_1.uniqueArray)([...object.required, ...allOfItem.required]);
                 let additionalProperties = [];
                 if (allOfItem.properties) {
                     additionalProperties = allOfItem.properties;
@@ -126,7 +124,7 @@ class APITypingsGenerator {
                 else if (allOfItem.ref) {
                     const refObject = this.getObjectByRef(allOfItem.ref);
                     if (!refObject) {
-                        log_1.consoleLogErrorAndExit(`${object.name} ref object in allOf is not found`);
+                        (0, log_1.consoleLogErrorAndExit)(`${object.name} ref object in allOf is not found`);
                         return;
                     }
                     additionalProperties = this.getObjectProperties(refObject, deep + 1);
@@ -166,7 +164,7 @@ class APITypingsGenerator {
         const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
             type: TypeCodeBlock_1.TypeScriptCodeTypes.Interface,
             refName: object.name,
-            interfaceName: helpers_1.getInterfaceName(object.name),
+            interfaceName: (0, helpers_1.getInterfaceName)(object.name),
             needExport: true,
             description: object.oneOf ? 'Object has oneOf' : '',
             properties: [],
@@ -175,16 +173,16 @@ class APITypingsGenerator {
             return this.getPrimitiveInterfaceCode(object);
         }
         properties.forEach((property) => {
-            const { imports: newImports, value, codeBlocks: newCodeBlocks, description, } = typeString_1.generateTypeString(property, this.objects, {
+            const { imports: newImports, value, codeBlocks: newCodeBlocks, description, } = (0, typeString_1.generateTypeString)(property, this.objects, {
                 objectParentName: object.name,
             });
-            imports = { ...imports, ...newImports };
+            imports = (0, mergeImports_1.mergeImports)(imports, newImports);
             codeBlocks = [...codeBlocks, ...newCodeBlocks];
             codeBlock.addProperty({
                 name: property.name,
                 description: [property.description, description].join(constants_1.newLineChar),
                 value,
-                isRequired: helpers_1.isPatternProperty(property.name) || property.isRequired,
+                isRequired: (0, helpers_1.isPatternProperty)(property.name) || property.isRequired,
             });
         });
         return {
@@ -198,7 +196,7 @@ class APITypingsGenerator {
             return this.getObjectCodeBlockAsType(object);
         }
         if (object.enum) {
-            const { codeBlocks } = enums_1.generateEnumAsUnionType(object);
+            const { codeBlocks } = (0, enums_1.generateEnumAsUnionType)(object);
             return {
                 codeBlocks: codeBlocks,
                 imports: {},
@@ -215,7 +213,7 @@ class APITypingsGenerator {
         }
         this.generatedObjects[object.name] = true;
         let result = false;
-        if (object.ref) {
+        if (object.ref && object.type === 'object') {
             result = this.getPrimitiveInterfaceCode(object);
         }
         else {
@@ -232,39 +230,39 @@ class APITypingsGenerator {
                     break;
                 default:
                     if (!result) {
-                        log_1.consoleLogErrorAndExit(helpers_1.getInterfaceName(object.name), 'Unknown type of object', object);
+                        (0, log_1.consoleLogErrorAndExit)((0, helpers_1.getInterfaceName)(object.name), 'Unknown type of object', object);
                     }
             }
         }
         if (!result) {
-            log_1.consoleLogErrorAndExit('empty object result', object);
+            (0, log_1.consoleLogErrorAndExit)('empty object result', object);
             return;
         }
         const { codeBlocks, imports } = result;
         const stringCodeBlocks = codeBlocks.map((codeBlock) => codeBlock.toString());
-        const section = helpers_1.getSectionFromObjectName(object.name);
+        const section = (0, helpers_1.getSectionFromObjectName)(object.name);
         delete imports[object.name];
-        stringCodeBlocks.unshift(generator_1.generateImportsBlock(imports, section, types_1.ObjectType.Object));
+        stringCodeBlocks.unshift((0, generator_1.generateImportsBlock)(imports, section, types_1.ObjectType.Object));
         if (stringCodeBlocks.length > 0) {
             const code = stringCodeBlocks.join(constants_1.newLineChar.repeat(2));
-            this.registerResultFile(path_1.default.join('objects', section, `${helpers_1.getInterfaceName(object.name)}.ts`), code);
+            this.registerResultFile(path_1.default.join('objects', section, `${(0, helpers_1.getInterfaceName)(object.name)}.ts`), code);
         }
         codeBlocks.forEach((codeBlock) => {
             if (codeBlock instanceof TypeCodeBlock_1.TypeCodeBlock && codeBlock.needExport && codeBlock.interfaceName) {
-                this.registerExport(`./objects/${section}/${helpers_1.getInterfaceName(object.name)}.ts`, codeBlock.interfaceName);
+                this.registerExport(`./objects/${section}/${(0, helpers_1.getInterfaceName)(object.name)}.ts`, codeBlock.interfaceName);
             }
         });
         this.generateObjectsFromImports(imports);
     }
     getObjectByRef(ref) {
-        const refName = helpers_1.getObjectNameByRef(ref);
+        const refName = (0, helpers_1.getObjectNameByRef)(ref);
         return this.objects[refName];
     }
     generateObjectsFromRefs(refs) {
         Object.keys(refs).forEach((ref) => {
             const refObject = this.getObjectByRef(ref);
             if (!refObject) {
-                log_1.consoleLogInfo(`"${ref}" ref is not found`);
+                (0, log_1.consoleLogInfo)(`"${ref}" ref is not found`);
                 return;
             }
             this.generateObject(refObject);
@@ -274,29 +272,29 @@ class APITypingsGenerator {
         Object.keys(imports).forEach((ref) => {
             const refObject = this.getObjectByRef(ref);
             if (!refObject) {
-                log_1.consoleLogInfo(`"${ref}" ref is not found`);
+                (0, log_1.consoleLogInfo)(`"${ref}" ref is not found`);
                 return;
             }
             this.generateObject(refObject);
         });
     }
     generateMethodParams(methodInfo) {
-        const section = helpers_1.getMethodSection(methodInfo.name);
-        const interfaceName = `${methodInfo.name} params`;
+        const section = (0, helpers_1.getMethodSection)(methodInfo.name);
+        const interfaceName = (0, helpers_1.getInterfaceName)(`${methodInfo.name} params`);
         let imports = {};
         let codeBlocks = [];
         const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
             type: TypeCodeBlock_1.TypeScriptCodeTypes.Interface,
-            interfaceName: helpers_1.getInterfaceName(interfaceName),
+            interfaceName: interfaceName,
             needExport: true,
             allowEmptyInterface: true,
             properties: [],
         });
         methodInfo.parameters.forEach((property) => {
-            const { imports: newImports, value, codeBlocks: newCodeBlocks, } = typeString_1.generateTypeString(property, this.objects, {
+            const { imports: newImports, value, codeBlocks: newCodeBlocks, } = (0, typeString_1.generateTypeString)(property, this.objects, {
                 needEnumNamesConstant: false,
             });
-            imports = { ...imports, ...newImports };
+            imports = (0, mergeImports_1.mergeImports)(imports, newImports);
             codeBlocks = [...codeBlocks, ...newCodeBlocks];
             codeBlock.addProperty({
                 name: property.name,
@@ -307,9 +305,10 @@ class APITypingsGenerator {
         });
         this.appendToFileMap(section, imports, [...codeBlocks, codeBlock]);
         this.generateObjectsFromImports(imports);
+        return interfaceName;
     }
     getResponseObjectRef(ref) {
-        const objectName = helpers_1.getObjectNameByRef(ref);
+        const objectName = (0, helpers_1.getObjectNameByRef)(ref);
         if (this.responses[objectName]) {
             return this.responses[objectName];
         }
@@ -319,15 +318,15 @@ class APITypingsGenerator {
         let codeBlocks = [];
         let imports = {};
         if (object.enum) {
-            const { codeBlocks: newCodeBlocks } = enums_1.generateEnumAsUnionType(object);
+            const { codeBlocks: newCodeBlocks } = (0, enums_1.generateEnumAsUnionType)(object);
             codeBlocks = [...newCodeBlocks];
         }
         else {
-            const { imports: newImports, value, codeBlocks: newCodeBlocks, } = typeString_1.generateTypeString(object, this.objects);
+            const { imports: newImports, value, codeBlocks: newCodeBlocks, } = (0, typeString_1.generateTypeString)(object, this.objects);
             const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
                 type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
                 refName: object.name,
-                interfaceName: helpers_1.getInterfaceName(object.name),
+                interfaceName: (0, helpers_1.getInterfaceName)(object.name),
                 description: object.description,
                 needExport: true,
                 properties: [],
@@ -343,13 +342,13 @@ class APITypingsGenerator {
         };
     }
     getResponseCodeBlockAsType(object, response) {
-        const { imports, value, codeBlocks, description } = typeString_1.generateTypeString(response, this.objects, {
+        const { imports, value, codeBlocks, description } = (0, typeString_1.generateTypeString)(response, this.objects, {
             objectParentName: ' ', // TODO: Refactor
         });
         const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
             type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
             refName: object.name,
-            interfaceName: helpers_1.getInterfaceName(object.name),
+            interfaceName: (0, helpers_1.getInterfaceName)(object.name),
             description: [object.description, description || ''].join(constants_1.newLineChar),
             needExport: true,
             properties: [],
@@ -364,7 +363,7 @@ class APITypingsGenerator {
     }
     getResponseCodeBlock(object) {
         if (!object.ref) {
-            log_1.consoleLogError(`response schema object "${object.name}" has no ref`, object);
+            (0, log_1.consoleLogError)(`response schema object "${object.name}" has no ref`, object);
             return false;
         }
         const nonBuildableRefs = {
@@ -372,13 +371,13 @@ class APITypingsGenerator {
             [constants_1.baseOkResponseRef]: true,
             [constants_1.basePropertyExistsRef]: true,
         };
-        const objectName = helpers_1.getObjectNameByRef(object.ref);
+        const objectName = (0, helpers_1.getObjectNameByRef)(object.ref);
         if (nonBuildableRefs[objectName]) {
             return this.getObjectCodeBlockAsType(object);
         }
         let response = this.getResponseObjectRef(object.ref);
         if (!response) {
-            log_1.consoleLogError(`response schema object "${object.name}" has no response`, object);
+            (0, log_1.consoleLogError)(`response schema object "${object.name}" has no response`, object);
             return false;
         }
         // VK API JSON Schema specific heuristic
@@ -399,14 +398,14 @@ class APITypingsGenerator {
             case 'array':
                 return this.getResponseCodeBlockAsType(object, response);
             default:
-                log_1.consoleLogErrorAndExit(response.name, 'unknown type', response.type);
+                (0, log_1.consoleLogErrorAndExit)(response.name, 'unknown type', response.type);
                 return false;
         }
     }
     generateResponse(section, response) {
         const result = this.getResponseCodeBlock(response);
         if (!result) {
-            return;
+            throw new Error('Unable to generate response');
         }
         const { codeBlocks, imports } = result;
         this.appendToFileMap(section, imports, codeBlocks);
@@ -414,13 +413,13 @@ class APITypingsGenerator {
     }
     generateMethodParamsAndResponses(method) {
         const { name: methodName } = method;
-        const section = helpers_1.getMethodSection(methodName);
-        if (!utils_1.isObject(method.responses)) {
-            log_1.consoleLogErrorAndExit(`"${methodName}" "responses" field is not an object.`);
+        const section = (0, helpers_1.getMethodSection)(methodName);
+        if (!(0, utils_1.isObject)(method.responses)) {
+            (0, log_1.consoleLogErrorAndExit)(`"${methodName}" "responses" field is not an object.`);
             return;
         }
         if (Object.keys(method.responses).length === 0) {
-            log_1.consoleLogErrorAndExit(`"${methodName}" "responses" field is empty.`);
+            (0, log_1.consoleLogErrorAndExit)(`"${methodName}" "responses" field is empty.`);
             return;
         }
         // Comment with method name for visual sections in file
@@ -429,38 +428,99 @@ class APITypingsGenerator {
             methodNameComment.appendLines(['', method.description]);
         }
         this.appendToFileMap(section, {}, [methodNameComment]);
-        const { method: normalizedMethod, parameterRefs } = methods_1.normalizeMethodInfo(method);
+        const { method: normalizedMethod, parameterRefs } = (0, methods_1.normalizeMethodInfo)(method);
         method = normalizedMethod;
         this.generateObjectsFromRefs(parameterRefs);
-        this.generateMethodParams(new SchemaObject_1.SchemaObject(method.name, method));
-        Object.entries(method.responses).forEach(([responseName, responseObject]) => {
+        const methodParamsInterfaceName = this.generateMethodParams(new SchemaObject_1.SchemaObject(method.name, method));
+        const methodResponsesInterfaceName = Object.entries(method.responses)
+            .map(([responseName, responseObject]) => {
             if (this.ignoredResponses[methodName] && this.ignoredResponses[methodName][responseName]) {
                 return;
             }
             const name = `${methodName}_${responseName}`;
-            this.generateResponse(section, new SchemaObject_1.SchemaObject(name, responseObject));
+            const interfaceName = (0, helpers_1.getInterfaceName)(name);
+            try {
+                this.generateResponse(section, new SchemaObject_1.SchemaObject(name, responseObject));
+                return interfaceName;
+            }
+            catch (e) {
+                return;
+            }
+        })
+            .filter(Boolean);
+        this.generateMethodType(methodName, methodParamsInterfaceName, methodResponsesInterfaceName);
+    }
+    generateMethodType(methodName, methodParamsInterfaceName, methodResponsesInterfaceName) {
+        const codeBlock = new TypeCodeBlock_1.TypeCodeBlock({
+            type: TypeCodeBlock_1.TypeScriptCodeTypes.Interface,
+            interfaceName: (0, helpers_1.getInterfaceName)(`${methodName} method`),
+            needExport: true,
+            allowEmptyInterface: true,
+            properties: [],
+        });
+        codeBlock.addProperty({
+            name: 'method',
+            value: methodName,
+            isRequired: true,
+            wrapValue: true,
+        });
+        codeBlock.addProperty({
+            name: 'request',
+            value: methodParamsInterfaceName,
+            isRequired: true,
+        });
+        codeBlock.addProperty({
+            name: 'response',
+            value: methodResponsesInterfaceName.length > 0
+                ? methodResponsesInterfaceName.join(' | ')
+                : 'unknown',
+            isRequired: true,
         });
+        const section = (0, helpers_1.getMethodSection)(methodName);
+        this.appendToFileMap(section, {}, [codeBlock]);
     }
     generateMethods() {
-        log_1.consoleLogInfo('creating method params and responses...');
+        (0, log_1.consoleLogInfo)('creating method params and responses...');
         this.methodsList.forEach((methodInfo) => {
-            if (helpers_1.isMethodNeeded(this.methodsPattern, methodInfo.name)) {
+            if ((0, helpers_1.isMethodNeeded)(this.methodsPattern, methodInfo.name)) {
                 this.generateMethodParamsAndResponses(methodInfo);
             }
         });
         Object.keys(this.methodFilesMap).forEach((section) => {
             const { imports, codeBlocks } = this.methodFilesMap[section];
+            const methodNames = [];
             codeBlocks.forEach((codeBlock) => {
                 if (codeBlock instanceof TypeCodeBlock_1.TypeCodeBlock && codeBlock.needExport && codeBlock.interfaceName) {
+                    /**
+                     * for interfaceName structure
+                     * @see this.generateMethodType
+                     */
+                    if (codeBlock.interfaceName.endsWith('Method')) {
+                        methodNames.push(codeBlock.interfaceName);
+                        // Skip export as it will be exported in union type
+                        return;
+                    }
                     this.registerExport(`./methods/${section}`, codeBlock.interfaceName);
                 }
             });
-            const code = [generator_1.generateImportsBlock(imports, null), ...codeBlocks];
+            if (methodNames.length > 0) {
+                const sectionMethodsCodeBlock = new TypeCodeBlock_1.TypeCodeBlock({
+                    type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
+                    interfaceName: (0, helpers_1.getInterfaceName)(`${section} methods union`),
+                    needExport: true,
+                    allowEmptyInterface: true,
+                    value: methodNames.join(' | '),
+                    properties: [],
+                });
+                codeBlocks.push(sectionMethodsCodeBlock);
+                this.registerExport(`./methods/${section}`, sectionMethodsCodeBlock.interfaceName);
+            }
+            const code = [(0, generator_1.generateImportsBlock)(imports, null), ...codeBlocks];
             this.registerResultFile(path_1.default.join('methods', `${section}.ts`), code.join(constants_1.newLineChar.repeat(2)));
         });
     }
     generateErrors() {
-        log_1.consoleLogInfo('creating errors...');
+        (0, log_1.consoleLogInfo)('creating errors...');
         const code = [];
         Object.entries(this.errors)
             .reduce((acc, [name, error]) => {
@@ -485,14 +545,14 @@ class APITypingsGenerator {
         this.registerResultFile(path_1.default.join('common', 'errors.ts'), code.join(constants_1.newLineChar.repeat(2)));
     }
     createCommonTypes() {
-        log_1.consoleLogInfo('creating common types...');
+        (0, log_1.consoleLogInfo)('creating common types...');
         const code = [];
         const apiVersion = this.methodsDefinitions.version || constants_1.DEFAULT_API_VERSION;
         code.push(`export const API_VERSION = '${apiVersion}'`);
         code.push('export type ValueOf<T> = T[keyof T];');
         code.push(new TypeCodeBlock_1.TypeCodeBlock({
             type: TypeCodeBlock_1.TypeScriptCodeTypes.Interface,
-            interfaceName: helpers_1.getInterfaceName(constants_1.baseAPIParamsInterfaceName),
+            interfaceName: (0, helpers_1.getInterfaceName)(constants_1.baseAPIParamsInterfaceName),
             needExport: true,
             properties: [
                 {
@@ -515,25 +575,82 @@ class APITypingsGenerator {
                 },
             ],
         }).toString());
+        code.push(`
+type MethodOf<M> = M extends { method: string } ? M['method'] : never;
+type RequestOf<M> = M extends { request: unknown } ? M['request'] : never;
+type ResponseOf<M> = M extends { response: unknown } ? M['response'] : never;
+
+export type CreateMethodMap<Type extends { method: string }> = {
+  [Property in Type as Property['method']]: {
+    method: MethodOf<Property>;
+    request: RequestOf<Property>;
+    response: ResponseOf<Property>;
+  };
+};
+    `);
         this.registerExport('./common/common', 'API_VERSION');
-        this.registerExport('./common/common', helpers_1.getInterfaceName(constants_1.baseAPIParamsInterfaceName));
+        this.registerExport('./common/common', (0, helpers_1.getInterfaceName)(constants_1.baseAPIParamsInterfaceName));
+        this.registerExport('./common/common', 'CreateMethodMap');
         this.registerResultFile(path_1.default.join('common', 'common.ts'), code.join(constants_1.newLineChar.repeat(2)));
     }
     /**
      * This method creates index.ts file with exports of all generated params, responses and objects
      */
     createIndexExports() {
-        log_1.consoleLogInfo('creating index.ts exports...');
+        (0, log_1.consoleLogInfo)('creating index.ts exports...');
         const blocks = [];
         let exportedObjects = {};
-        utils_1.sortArrayAlphabetically(Object.keys(this.exports)).forEach((path) => {
+        let methodNames = new Set();
+        (0, utils_1.sortArrayAlphabetically)(Object.keys(this.exports)).forEach((path) => {
+            if (!path.startsWith('./methods/')) {
+                return;
+            }
+            const objects = Object.keys(this.exports[path]);
+            if (!objects.length) {
+                return;
+            }
+            const blockLines = [];
+            (0, utils_1.sortArrayAlphabetically)(objects).forEach((object) => {
+                /**
+                 * for interfaceName structure
+                 * @see this.generateMethods
+                 */
+                if (!methodNames.has(object) && /^[A-Z][a-zA-Z0-9]*MethodsUnion$/.test(object)) {
+                    methodNames.add(object);
+                    exportedObjects[object] = true; // To skip in export block
+                    blockLines.push(`  ${object},`);
+                }
+            });
+            if (blockLines.length > 0) {
+                blockLines.unshift('import type {');
+                blockLines.push(`} from '${path.replace('.ts', '')}';`);
+                blocks.push(blockLines.join(constants_1.newLineChar));
+            }
+        });
+        blocks.push("import type { CreateMethodMap } from './common/common';");
+        const methodsCodeBlock = new TypeCodeBlock_1.TypeCodeBlock({
+            type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
+            interfaceName: 'ApiMethodsUnion',
+            needExport: false,
+            properties: [],
+            value: Array.from(methodNames).join(' | '),
+        });
+        blocks.push(methodsCodeBlock.toString());
+        blocks.push(new TypeCodeBlock_1.TypeCodeBlock({
+            type: TypeCodeBlock_1.TypeScriptCodeTypes.Type,
+            interfaceName: 'ApiMethodsMap',
+            needExport: true,
+            properties: [],
+            value: `CreateMethodMap<${methodsCodeBlock.interfaceName}>`,
+        }).toString());
+        (0, utils_1.sortArrayAlphabetically)(Object.keys(this.exports)).forEach((path) => {
             const objects = Object.keys(this.exports[path]);
             if (!objects.length) {
                 return;
             }
             const blockLines = [];
             blockLines.push('export {');
-            utils_1.sortArrayAlphabetically(objects).forEach((object) => {
+            (0, utils_1.sortArrayAlphabetically)(objects).forEach((object) => {
                 if (exportedObjects[object]) {
                     return;
                 }
@@ -544,21 +661,21 @@ class APITypingsGenerator {
             blocks.push(blockLines.join(constants_1.newLineChar));
         });
         this.registerResultFile('index.ts', blocks.join(constants_1.newLineChar.repeat(2)));
-        log_1.consoleLogInfo(`${Object.keys(exportedObjects).length} objects successfully generated`);
+        (0, log_1.consoleLogInfo)(`${Object.keys(exportedObjects).length} objects successfully generated`);
     }
     generate() {
-        log_1.consoleLogInfo('generate');
+        (0, log_1.consoleLogInfo)('generate');
         this.generateMethods();
         this.generateErrors();
         if (this.needEmit) {
             this.createCommonTypes();
             this.createIndexExports();
-            log_1.consoleLogInfo('prepare out directory');
-            helpers_1.prepareBuildDirectory(this.outDirPath);
-            log_1.consoleLogInfo('write files');
+            (0, log_1.consoleLogInfo)('prepare out directory');
+            (0, helpers_1.prepareBuildDirectory)(this.outDirPath);
+            (0, log_1.consoleLogInfo)('write files');
             Object.keys(this.resultFiles).forEach((filePath) => {
                 const fileContent = this.resultFiles[filePath];
-                helpers_1.writeFile(path_1.default.join(this.outDirPath, filePath), fileContent);
+                (0, helpers_1.writeFile)(path_1.default.join(this.outDirPath, filePath), fileContent);
             });
         }
     }

package/dist/generators/SchemaObject.js

@@ -6,8 +6,8 @@ const helpers_1 = require("../helpers");
 const log_1 = require("../log");
 class SchemaObject {
     constructor(name, object, parentName) {
-        if (!utils_1.isObject(object)) {
-            log_1.consoleLogErrorAndExit(`[SchemaObject] "${name}" is not an object.`, {
+        if (!(0, utils_1.isObject)(object)) {
+            (0, log_1.consoleLogErrorAndExit)(`[SchemaObject] "${name}" is not an object.`, {
                 name,
                 object,
                 parentName,
@@ -18,16 +18,16 @@ class SchemaObject {
         if (parentName) {
             this.parentObjectName = parentName;
         }
-        if (utils_1.isString(object.type)) {
+        if ((0, utils_1.isString)(object.type)) {
             this.type = object.type;
         }
         else if (Array.isArray(object.type)) {
             this.type = object.type;
         }
-        if (utils_1.isString(object.description)) {
+        if ((0, utils_1.isString)(object.description)) {
             this.description = object.description;
         }
-        if (utils_1.isString(object.$ref)) {
+        if ((0, utils_1.isString)(object.$ref)) {
             this.ref = object.$ref;
         }
         if (Array.isArray(object.enum)) {
@@ -59,10 +59,10 @@ class SchemaObject {
         }
         if (object.patternProperties) {
             Object.entries(object.patternProperties).forEach(([propertyName, property]) => {
-                this.properties.push(new SchemaObject(helpers_1.transformPatternPropertyName(propertyName), property, name));
+                this.properties.push(new SchemaObject((0, helpers_1.transformPatternPropertyName)(propertyName), property, name));
             });
         }
-        if (utils_1.isObject(object.items)) {
+        if ((0, utils_1.isObject)(object.items)) {
             this.items = new SchemaObject(name + '_items', object.items, this.name);
         }
         if (Array.isArray(object.oneOf) && object.oneOf.length > 0) {