swaggular 0.1.0

package/dist/generators/generate-service.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateServices = generateServices;
+exports.generateServiceFiles = generateServiceFiles;
+exports.buildMethods = buildMethods;
+exports.buildMethod = buildMethod;
+exports.computeName = computeName;
+const services_store_1 = require("../stores/services-store");
+const swagger_store_1 = require("../stores/swagger-store");
+const angular_template_1 = require("../templates/services/angular-template");
+const build_types_1 = require("../utils/build-types");
+const path_utils_1 = require("../utils/path-utils");
+const string_utils_1 = require("../utils/string-utils");
+const type_guard_1 = require("../utils/type-guard");
+const generate_interface_1 = require("./generate-interface");
+const generate_comments_1 = require("./generate-comments");
+/**
+ * Pick the paths grouped by scope and generate services for them.
+ * Each group will generate one service data.
+ * Each service data will contain the methods for the paths.
+ *
+ * The name will be the group name concatenated with Service
+ *
+ * The imports will be the types used in the methods. Including
+ * the response type and the parameters types.
+ *
+ * The base url will be the base url of the group compound by the
+ * base segments of the group.
+ *
+ * Each method will be generated based on a path
+ *
+ * The method name will be computed based on the path.
+ * It has to follow some stantardized rules.
+ *
+ * The method parameters will be computed based on the path parameters
+ * The method path will be computed based on the path, but it will be
+ * computed as `${this.baseUrl}/something/else/{id}`
+ * The method response type will be computed based on the path response
+ * The method parameters will be computed based on the path parameters
+ * The method parameter name will be computed based on the path parameter name if
+ * the parameters has the property "in" set to "path". If the parameter has the property
+ * "in" set to "query", it will be computed as "parameters" and query parameters should be grouped
+ * in the same object. Check computeParametersName() method in generate-interface.ts to
+ * understand how the name is computed.
+ *
+ * The method parameter in property will be computed based on the path parameter "in" property
+ * The method parameter type will be computed based on the path parameter type property.
+ * Check computeParametersName() method in generate-interface.ts to
+ * understand how the name is computed.
+ * The method parameter required will be computed based on the path parameter required property
+ * @returns ServiceData[]
+ */
+function generateServices() {
+    const servicesData = [];
+    const groupedPaths = swagger_store_1.swaggerStore.getPathsGroupedByScope();
+    const paths = swagger_store_1.swaggerStore.getPaths();
+    if (!groupedPaths || !paths)
+        return;
+    for (const [key, value] of Object.entries(groupedPaths)) {
+        const methods = buildMethods(value);
+        const importsSet = new Set();
+        methods.forEach((method) => {
+            const allTypes = [
+                method.responseType,
+                ...method.parameters.map((p) => p.type),
+            ];
+            allTypes.forEach((t) => {
+                const identifiers = t.match(/[a-zA-Z_][a-zA-Z0-9_]*/g) || [];
+                identifiers.forEach((id) => {
+                    if (!(0, type_guard_1.isNativeType)(id) && id !== "void") {
+                        importsSet.add(id);
+                    }
+                });
+            });
+        });
+        const serviceData = {
+            name: key + "Service",
+            imports: Array.from(importsSet),
+            baseUrl: value.baseUrl,
+            methods: methods,
+        };
+        servicesData.push(serviceData);
+    }
+    services_store_1.serviceStore.addServices(servicesData);
+}
+function generateServiceFiles(locations) {
+    const services = Object.values(services_store_1.serviceStore.services);
+    const filesContent = [];
+    for (const service of services) {
+        const methodsString = service.methods
+            .map((method) => generateMethodString(method))
+            .join("\n\n");
+        const templateParams = {
+            name: service.name.replace("Service", ""),
+            baseUrl: service.baseUrl,
+            methods: methodsString,
+            imports: service.imports.join(", "),
+            hasHttpParamsHandler: service.methods.some((m) => m.parameters.some((p) => p.in === "query")),
+        };
+        // If imports are empty, we might want to clean up the template later,
+        // but for now we follow the existing template structure.
+        filesContent.push({
+            location: ["services", ...(locations?.[service.name] ?? [])],
+            name: (0, string_utils_1.toKebabCase)(service.name.replace("Service", "")) + ".service",
+            content: (0, angular_template_1.angularServiceTemplate)(templateParams),
+            extension: "ts",
+        });
+    }
+    return filesContent;
+}
+function generateMethodString(method) {
+    const paramsSignature = method.parameters
+        .map((p) => `${p.name}${p.required ? "" : "?"}: ${p.type}`)
+        .join(", ");
+    const httpMethod = method.method.toLowerCase();
+    const responseType = method.responseType;
+    // Convert {id} to ${id} in path
+    let path = method.path.replace(/{([^}]+)}/g, "${$1}");
+    if (!path.startsWith("`")) {
+        // Remove the first $
+        path = `\`${path.slice(1)}\``;
+    }
+    let body = "";
+    const queryParam = method.parameters.find((p) => p.in === "query");
+    if (queryParam) {
+        body += `    const params = HttpHelper.toHttpParams(${queryParam.name} ?? {});\n`;
+    }
+    const options = [];
+    if (queryParam)
+        options.push("params");
+    if (responseType === "Blob" || responseType === "File") {
+        options.push("responseType: 'blob'");
+    }
+    if (httpMethod === "delete" &&
+        method.parameters.some((p) => p.in === "body")) {
+        options.push("body: " + method.parameters.find((p) => p.in === "body")?.name);
+    }
+    const optionsString = options.length > 0 ? `, { ${options.join(", ")} }` : "";
+    if (httpMethod === "get" || httpMethod === "delete") {
+        body += `    return this.http.${httpMethod}<${responseType}>(${path}${optionsString});`;
+    }
+    else {
+        // post, put, patch
+        const dataParam = method.parameters.find((p) => p.in === "body")?.name || "null";
+        body += `    return this.http.${httpMethod}<${responseType}>(${path}, ${dataParam}${optionsString});`;
+    }
+    return `${method.comments}\n  public ${method.name}(${paramsSignature}): Observable<${responseType}> {
+${body}
+  }`;
+}
+function buildMethods(groupedPath) {
+    const methods = [];
+    const pathData = swagger_store_1.swaggerStore.getPaths();
+    const usedNames = [];
+    for (const path of groupedPath.paths) {
+        if (!pathData || !pathData[path])
+            continue;
+        for (const [httpMethod, pathInfo] of Object.entries(pathData[path])) {
+            if (typeof pathInfo !== "object")
+                continue;
+            const method = buildMethod(path, httpMethod, pathInfo, groupedPath, usedNames);
+            methods.push(method);
+            usedNames.push(method.name);
+        }
+    }
+    return methods;
+}
+function buildMethod(path, httpMethod, pathInfo, groupedPath, usedNames) {
+    const baseUrl = groupedPath.baseUrl;
+    const extraSegments = (0, path_utils_1.getExtraSegments)(path, baseUrl).join("/");
+    const methodPath = extraSegments
+        ? `\${this.baseUrl}/${extraSegments}`
+        : `\${this.baseUrl}`;
+    const responseType = getMethodResponseType(pathInfo);
+    const parameters = getMethodParameters(path, httpMethod, pathInfo, groupedPath);
+    const method = {
+        name: computeName(path, httpMethod, usedNames),
+        path: methodPath,
+        method: httpMethod,
+        parameters: parameters,
+        responseType: responseType,
+        comments: (0, generate_comments_1.generateServiceComments)(pathInfo.summary || "", responseType, parameters),
+    };
+    return method;
+}
+function getMethodResponseType(pathInfo) {
+    const responses = pathInfo.responses;
+    if (!responses)
+        return "void";
+    const successResponse = responses["200"] || responses["201"] || responses["default"];
+    if (!successResponse)
+        return "void";
+    if ((0, type_guard_1.isReference)(successResponse)) {
+        return "any";
+    }
+    const content = successResponse.content;
+    if (!content || !content["application/json"])
+        return "void";
+    const schema = content["application/json"].schema;
+    if (!schema)
+        return "void";
+    return (0, build_types_1.switchTypeJson)(schema);
+}
+function getMethodParameters(path, httpMethod, pathInfo, groupedPath) {
+    const parameters = [];
+    const openApiParameters = pathInfo.parameters || [];
+    // Path parameters
+    openApiParameters.forEach((param) => {
+        if ((0, type_guard_1.isReference)(param))
+            return;
+        if (param.in === "path") {
+            parameters.push({
+                name: param.name,
+                in: "path",
+                required: param.required || false,
+                type: (0, build_types_1.switchTypeJson)(param.schema),
+            });
+        }
+    });
+    // Query parameters (grouped)
+    const queryParams = openApiParameters.filter((param) => !(0, type_guard_1.isReference)(param) && param.in === "query");
+    if (queryParams.length > 0) {
+        parameters.push({
+            name: "parameters",
+            in: "query",
+            required: queryParams.some((p) => p.required),
+            type: (0, generate_interface_1.computeParametersName)(httpMethod, path, groupedPath),
+        });
+    }
+    // Request Body
+    if (pathInfo.requestBody) {
+        let bodyType = "any";
+        if ((0, type_guard_1.isReference)(pathInfo.requestBody)) {
+            bodyType = pathInfo.requestBody.$ref.split("/").pop();
+        }
+        else {
+            const content = pathInfo.requestBody.content;
+            if (content && content["application/json"]) {
+                const schema = content["application/json"].schema;
+                if (schema) {
+                    bodyType = (0, build_types_1.switchTypeJson)(schema);
+                }
+            }
+        }
+        parameters.push({
+            name: "data",
+            in: "body",
+            required: true,
+            type: bodyType,
+        });
+    }
+    return parameters;
+}
+function computeName(path, httpMethod, usedNames) {
+    const dict = {
+        get: "get",
+        post: "create",
+        put: "update",
+        delete: "delete",
+        patch: "patch",
+    };
+    const parts = path.split("/").filter((p) => p);
+    const endsInVariable = (0, path_utils_1.isVariable)(parts[parts.length - 1]);
+    if (endsInVariable) {
+        const name = dict[httpMethod];
+        if (usedNames.includes(name)) {
+            return name + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 2]);
+        }
+        return name;
+    }
+    if (httpMethod === "get" || httpMethod === "put" || httpMethod === "patch") {
+        let name = dict[httpMethod] + "All";
+        if (!usedNames.includes(name)) {
+            return name;
+        }
+        name = dict[httpMethod] + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
+        if (!usedNames.includes(name)) {
+            return name;
+        }
+        return dict[httpMethod] + "By" + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
+    }
+    if (httpMethod === "post") {
+        let name = dict[httpMethod];
+        if (!usedNames.includes(name)) {
+            return name;
+        }
+        name = (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
+        if (!usedNames.includes(name)) {
+            return name;
+        }
+        name = "createBy" + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
+        if (!usedNames.includes(name)) {
+            return name;
+        }
+        return "create" + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
+    }
+    const name = dict[httpMethod];
+    if (usedNames.includes(name)) {
+        return name + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
+    }
+    return name + "By" + (0, string_utils_1.kebabToPascalCase)(parts[parts.length - 1]);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const fs_1 = __importDefault(require("fs"));
+const swagger_parser_1 = require("./parsers/swagger-parser");
+const generate_interface_1 = require("./renderers/generate-interface");
+const generate_service_1 = require("./renderers/generate-service");
+const args_1 = require("./cli/args");
+const variables_1 = require("./cli/variables");
+const create_file_1 = require("./utils/create-file");
+async function main() {
+    try {
+        const parsed = (0, args_1.getParseArgs)(process.argv.slice(2));
+        const variables = (0, variables_1.toVariables)(parsed);
+        swagger_parser_1.SwaggerParser.parse(parsed.args.input, {
+            mode: variables.groupingMode,
+            segmentsToIgnore: variables.segmentsToIgnore,
+            ignoreVariables: variables.ignoreVariables,
+        });
+        (0, generate_interface_1.generateInterfaces)();
+        (0, generate_service_1.generateServices)();
+        const interfaceFiles = (0, generate_interface_1.generateInterfacesFiles)();
+        const serviceFiles = (0, generate_service_1.generateServiceFiles)();
+        if (parsed.args.noGenerate) {
+            console.log('No se generaron archivos');
+            return;
+        }
+        if (fs_1.default.existsSync('results')) {
+            fs_1.default.rmSync('results', { recursive: true, force: true });
+        }
+        await (0, create_file_1.createFileFromFileContents)('results/models', interfaceFiles);
+        await (0, create_file_1.createFileFromFileContents)('results', serviceFiles);
+        console.log('Archivo creado correctamente');
+    }
+    catch (err) {
+        console.error('Failed to read JSON:', err);
+    }
+}
+if (require.main === module) {
+    main();
+}

package/dist/models/file-content.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/grouped-paths.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/interface-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/parsed-args.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/service-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularRequestType = exports.AngularResponseType = exports.NativeType = void 0;
+var NativeType;
+(function (NativeType) {
+    NativeType["String"] = "string";
+    NativeType["Number"] = "number";
+    NativeType["Boolean"] = "boolean";
+    NativeType["Array"] = "Array";
+    NativeType["Date"] = "Date";
+    NativeType["File"] = "File";
+    NativeType["Any"] = "any";
+    NativeType["Void"] = "void";
+})(NativeType || (exports.NativeType = NativeType = {}));
+var AngularResponseType;
+(function (AngularResponseType) {
+    AngularResponseType["Json"] = "json";
+    AngularResponseType["Text"] = "text";
+    AngularResponseType["Blob"] = "blob";
+    AngularResponseType["ArrayBuffer"] = "arrayBuffer";
+})(AngularResponseType || (exports.AngularResponseType = AngularResponseType = {}));
+var AngularRequestType;
+(function (AngularRequestType) {
+    AngularRequestType["Get"] = "get";
+    AngularRequestType["Post"] = "post";
+    AngularRequestType["Put"] = "put";
+    AngularRequestType["Delete"] = "delete";
+    AngularRequestType["Patch"] = "patch";
+})(AngularRequestType || (exports.AngularRequestType = AngularRequestType = {}));

package/dist/parsers/path-grouper.d.ts

@@ -0,0 +1,17 @@
+import { OpenAPIV3 } from 'openapi-types';
+import { GroupedPaths } from '../types/grouped-paths';
+export interface GroupPathsOptions {
+    mode: 'tags' | 'path';
+    segmentsToIgnore?: string[];
+    ignoreVariables?: boolean;
+}
+export declare class PathGrouper {
+    static groupPaths(paths: OpenAPIV3.PathsObject, options?: GroupPathsOptions): GroupedPaths;
+    private static groupByTags;
+    private static groupByPath;
+    private static splitRecursively;
+    private static addToFinalGroups;
+    private static getNormalizedSegments;
+    private static getMethodCount;
+    private static getCommonSegments;
+}

package/dist/parsers/path-grouper.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathGrouper = void 0;
+const path_utils_1 = require("../utils/path-utils");
+const string_utils_1 = require("../utils/string-utils");
+class PathGrouper {
+    static groupPaths(paths, options = { mode: 'tags' }) {
+        if (options.mode === 'tags') {
+            return this.groupByTags(paths, options);
+        }
+        else {
+            return this.groupByPath(paths, options);
+        }
+    }
+    static groupByTags(paths, options) {
+        const tagGroups = {};
+        const methods = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'];
+        for (const [pathKey, pathItem] of Object.entries(paths)) {
+            if (!pathItem)
+                continue;
+            const tags = new Set();
+            for (const method of methods) {
+                const operation = pathItem[method];
+                if (operation?.tags && operation.tags.length > 0) {
+                    operation.tags.forEach((tag) => tags.add((0, string_utils_1.removeAllWhitespace)(tag)));
+                }
+            }
+            if (tags.size === 0) {
+                const groupKey = 'Default';
+                if (!tagGroups[groupKey])
+                    tagGroups[groupKey] = [];
+                tagGroups[groupKey].push(pathKey);
+            }
+            else {
+                tags.forEach((tag) => {
+                    if (!tagGroups[tag])
+                        tagGroups[tag] = [];
+                    tagGroups[tag].push(pathKey);
+                });
+            }
+        }
+        const finalGroups = {};
+        const sortedTags = Object.keys(tagGroups).sort();
+        for (const tagName of sortedTags) {
+            const pathKeys = tagGroups[tagName].sort();
+            const totalMethods = pathKeys.reduce((sum, pk) => sum + this.getMethodCount(paths[pk]), 0);
+            if (totalMethods <= 8) {
+                const groupName = (0, string_utils_1.toPascalCase)([tagName]);
+                finalGroups[groupName] = {
+                    groupName,
+                    baseSegments: this.getCommonSegments(pathKeys),
+                    paths: pathKeys,
+                    baseUrl: (0, path_utils_1.findCommonBaseUrl)(pathKeys),
+                };
+            }
+            else {
+                const commonSegs = this.getCommonSegments(pathKeys);
+                this.splitRecursively(paths, pathKeys, commonSegs, options, finalGroups, commonSegs.length, tagName);
+            }
+        }
+        return finalGroups;
+    }
+    static groupByPath(paths, options) {
+        const finalGroups = {};
+        const pathKeys = Object.keys(paths).filter((k) => !!paths[k]);
+        const initialBuckets = {};
+        for (const pk of pathKeys) {
+            const normalized = this.getNormalizedSegments(pk, options);
+            const first = normalized.length > 0 ? normalized[0] : 'Default';
+            if (!initialBuckets[first])
+                initialBuckets[first] = [];
+            initialBuckets[first].push(pk);
+        }
+        const sortedPrimaryKeys = Object.keys(initialBuckets).sort();
+        for (const primaryKey of sortedPrimaryKeys) {
+            const pathsInBucket = initialBuckets[primaryKey];
+            const prefix = primaryKey === 'Default' ? [] : [primaryKey];
+            this.splitRecursively(paths, pathsInBucket, prefix, options, finalGroups, 0);
+        }
+        const sortedResult = {};
+        const sortedGroupNames = Object.keys(finalGroups).sort();
+        for (const name of sortedGroupNames) {
+            sortedResult[name] = finalGroups[name];
+        }
+        return sortedResult;
+    }
+    static splitRecursively(allPaths, currentPaths, currentPrefix, options, finalGroups, initialDepth, customNamePrefix) {
+        const totalMethods = currentPaths.reduce((sum, pk) => sum + this.getMethodCount(allPaths[pk]), 0);
+        const depth = currentPrefix.length;
+        if (totalMethods <= 8) {
+            this.addToFinalGroups(currentPaths, currentPrefix, finalGroups, initialDepth, customNamePrefix);
+            return;
+        }
+        const stayers = [];
+        const branchMap = {};
+        for (const pk of currentPaths) {
+            const normalized = this.getNormalizedSegments(pk, options);
+            if (normalized.length > depth) {
+                const next = normalized[depth];
+                if (!branchMap[next])
+                    branchMap[next] = [];
+                branchMap[next].push(pk);
+            }
+            else {
+                stayers.push(pk);
+            }
+        }
+        const nextSegs = Object.keys(branchMap);
+        if (nextSegs.length === 0) {
+            this.addToFinalGroups(currentPaths, currentPrefix, finalGroups, initialDepth, customNamePrefix);
+            return;
+        }
+        const movingBranches = [];
+        const remainingToStay = [...stayers];
+        for (const seg of nextSegs) {
+            const paths = branchMap[seg];
+            const count = paths.reduce((sum, pk) => sum + this.getMethodCount(allPaths[pk]), 0);
+            if (count >= 2) {
+                movingBranches.push({ seg, paths });
+            }
+            else {
+                remainingToStay.push(...paths);
+            }
+        }
+        if (movingBranches.length === 0) {
+            this.addToFinalGroups(currentPaths, currentPrefix, finalGroups, initialDepth, customNamePrefix);
+            return;
+        }
+        if (movingBranches.length === 1 && remainingToStay.length === 0) {
+            this.splitRecursively(allPaths, currentPaths, [...currentPrefix, movingBranches[0].seg], options, finalGroups, initialDepth, customNamePrefix);
+            return;
+        }
+        if (remainingToStay.length > 0) {
+            this.addToFinalGroups(remainingToStay, currentPrefix, finalGroups, initialDepth, customNamePrefix);
+        }
+        for (const branch of movingBranches.sort((a, b) => a.seg.localeCompare(b.seg))) {
+            this.splitRecursively(allPaths, branch.paths, [...currentPrefix, branch.seg], options, finalGroups, initialDepth, customNamePrefix);
+        }
+    }
+    static addToFinalGroups(paths, prefix, finalGroups, initialDepth, customNamePrefix) {
+        let groupName;
+        if (customNamePrefix) {
+            const trailing = prefix.slice(initialDepth);
+            groupName = (0, string_utils_1.toPascalCase)([customNamePrefix, ...trailing]);
+        }
+        else {
+            groupName = prefix.length > 0 ? (0, string_utils_1.toPascalCase)(prefix) : 'Default';
+        }
+        if (finalGroups[groupName]) {
+            const existing = finalGroups[groupName];
+            existing.paths = [...new Set([...existing.paths, ...paths])].sort();
+            existing.baseSegments = this.getCommonSegments(existing.paths);
+            existing.baseUrl = (0, path_utils_1.findCommonBaseUrl)(existing.paths);
+        }
+        else {
+            finalGroups[groupName] = {
+                groupName,
+                baseSegments: this.getCommonSegments(paths),
+                paths: paths.sort(),
+                baseUrl: (0, path_utils_1.findCommonBaseUrl)(paths),
+            };
+        }
+    }
+    static getNormalizedSegments(path, options) {
+        const segments = path.split('/').filter((s) => s);
+        const result = [];
+        for (const segment of segments) {
+            if (options.segmentsToIgnore?.includes(segment))
+                continue;
+            if (options.ignoreVariables && (0, path_utils_1.isVariable)(segment))
+                continue;
+            result.push(segment);
+        }
+        return result;
+    }
+    static getMethodCount(pathItem) {
+        const methods = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'];
+        let count = 0;
+        for (const method of methods) {
+            if (pathItem[method]) {
+                count++;
+            }
+        }
+        return count;
+    }
+    static getCommonSegments(paths) {
+        if (paths.length === 0)
+            return [];
+        const pathSegments = paths.map((p) => p
+            .replace(/^\/+api\/+/, '')
+            .split('/')
+            .filter((s) => s));
+        const firstPath = pathSegments[0];
+        const common = [];
+        for (let i = 0; i < firstPath.length; i++) {
+            const segment = firstPath[i];
+            if (pathSegments.every((ps) => ps[i] === segment)) {
+                common.push(segment);
+            }
+            else {
+                break;
+            }
+        }
+        return common;
+    }
+}
+exports.PathGrouper = PathGrouper;

package/dist/parsers/swagger-parser.d.ts

@@ -0,0 +1,4 @@
+import { GroupPathsOptions } from './path-grouper';
+export declare class SwaggerParser {
+    static parse(filePath: string, options?: GroupPathsOptions): void;
+}