ts-openapi-codegen 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/core/api/v2/parser/getOperation.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperation = getOperation;
+const getComment_1 = require("../../../utils/getComment");
+const getOperationErrors_1 = require("../../../utils/getOperationErrors");
+const getOperationName_1 = require("../../../utils/getOperationName");
+const getOperationPath_1 = require("../../../utils/getOperationPath");
+const getOperationResponseHeader_1 = require("../../../utils/getOperationResponseHeader");
+const getOperationResults_1 = require("../../../utils/getOperationResults");
+const getServiceClassName_1 = require("../../../utils/getServiceClassName");
+function getOperation(openApi, url, method, op, pathParams) {
+    const serviceName = op.tags?.[0] || 'Service';
+    const serviceClassName = (0, getServiceClassName_1.getServiceClassName)(serviceName);
+    const operationNameFallback = `${method}${serviceClassName}`;
+    const operationName = (0, getOperationName_1.getOperationName)(op.operationId || operationNameFallback);
+    const operationPath = (0, getOperationPath_1.getOperationPath)(url);
+    // Create a new operation object for this method.
+    const operation = {
+        service: serviceClassName,
+        name: operationName,
+        summary: (0, getComment_1.getComment)(op.summary),
+        description: (0, getComment_1.getComment)(op.description),
+        deprecated: op.deprecated === true,
+        method: method.toUpperCase(),
+        path: operationPath,
+        parameters: [...pathParams.parameters],
+        parametersPath: [...pathParams.parametersPath],
+        parametersQuery: [...pathParams.parametersQuery],
+        parametersForm: [...pathParams.parametersForm],
+        parametersHeader: [...pathParams.parametersHeader],
+        parametersCookie: [...pathParams.parametersCookie],
+        parametersBody: pathParams.parametersBody,
+        imports: [],
+        errors: [],
+        results: [],
+        responseHeader: null,
+    };
+    // Parse the operation parameters (path, query, body, etc).
+    if (op.parameters) {
+        const parameters = this.getOperationParameters(openApi, op.parameters);
+        operation.imports.push(...parameters.imports);
+        operation.parameters.push(...parameters.parameters);
+        operation.parametersPath.push(...parameters.parametersPath);
+        operation.parametersQuery.push(...parameters.parametersQuery);
+        operation.parametersForm.push(...parameters.parametersForm);
+        operation.parametersHeader.push(...parameters.parametersHeader);
+        operation.parametersCookie.push(...parameters.parametersCookie);
+        operation.parametersBody = parameters.parametersBody;
+    }
+    // Parse the operation responses.
+    if (op.responses) {
+        const operationResponses = this.getOperationResponses(openApi, op.responses);
+        const operationResults = (0, getOperationResults_1.getOperationResults)(operationResponses);
+        operation.errors = (0, getOperationErrors_1.getOperationErrors)(operationResponses);
+        operation.responseHeader = (0, getOperationResponseHeader_1.getOperationResponseHeader)(operationResults);
+        operationResults.forEach(operationResult => {
+            operation.results.push(operationResult);
+            operation.imports.push(...operationResult.imports);
+        });
+    }
+    return operation;
+}

package/dist/core/api/v2/parser/getOperationParameter.d.ts

@@ -0,0 +1,6 @@
+import type { OperationParameter } from '../../../types/shared/OperationParameter.model';
+import { Parser } from '../Parser';
+import type { OpenApi } from '../types/OpenApi.model';
+import type { OpenApiParameter } from '../types/OpenApiParameter.model';
+export declare function getOperationParameter(this: Parser, openApi: OpenApi, parameter: OpenApiParameter): OperationParameter;
+//# sourceMappingURL=getOperationParameter.d.ts.map

package/dist/core/api/v2/parser/getOperationParameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationParameter.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getOperationParameter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AAOzF,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAGxE,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,gBAAgB,GAAG,kBAAkB,CAsIrH"}

package/dist/core/api/v2/parser/getOperationParameter.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperationParameter = getOperationParameter;
+const extendEnum_1 = require("../../../utils/extendEnum");
+const getComment_1 = require("../../../utils/getComment");
+const getEnum_1 = require("../../../utils/getEnum");
+const getEnumFromDescription_1 = require("../../../utils/getEnumFromDescription");
+const getOperationParameterName_1 = require("../../../utils/getOperationParameterName");
+const getPattern_1 = require("../../../utils/getPattern");
+const getOperationParameterDefault_1 = require("./getOperationParameterDefault");
+function getOperationParameter(openApi, parameter) {
+    const operationParameter = {
+        path: '',
+        in: parameter.in,
+        prop: parameter.name,
+        export: 'interface',
+        name: (0, getOperationParameterName_1.getOperationParameterName)(parameter.name),
+        alias: '',
+        type: 'any',
+        base: 'any',
+        template: null,
+        link: null,
+        description: (0, getComment_1.getComment)(parameter.description),
+        isDefinition: false,
+        isReadOnly: false,
+        isRequired: parameter.required === true,
+        isNullable: parameter['x-nullable'] === true,
+        format: parameter.format,
+        maximum: parameter.maximum,
+        exclusiveMaximum: parameter.exclusiveMaximum,
+        minimum: parameter.minimum,
+        exclusiveMinimum: parameter.exclusiveMinimum,
+        multipleOf: parameter.multipleOf,
+        maxLength: parameter.maxLength,
+        minLength: parameter.minLength,
+        maxItems: parameter.maxItems,
+        minItems: parameter.minItems,
+        uniqueItems: parameter.uniqueItems,
+        pattern: (0, getPattern_1.getPattern)(parameter.pattern),
+        imports: [],
+        enum: [],
+        enums: [],
+        properties: [],
+        mediaType: null,
+    };
+    if (parameter.$ref) {
+        const definitionRef = this.getType(parameter.$ref, '');
+        operationParameter.export = 'reference';
+        operationParameter.type = definitionRef.type;
+        operationParameter.base = definitionRef.base;
+        operationParameter.template = definitionRef.template;
+        operationParameter.imports.push(...definitionRef.imports);
+        operationParameter.default = (0, getOperationParameterDefault_1.getOperationParameterDefault)(parameter, operationParameter);
+        operationParameter.path = definitionRef.path;
+        return operationParameter;
+    }
+    if (parameter.enum) {
+        const enumerators = (0, getEnum_1.getEnum)(parameter.enum);
+        const extendedEnumerators = (0, extendEnum_1.extendEnum)(enumerators, parameter);
+        if (extendedEnumerators.length) {
+            operationParameter.export = 'enum';
+            operationParameter.type = 'string';
+            operationParameter.base = 'string';
+            operationParameter.enum.push(...extendedEnumerators);
+            operationParameter.default = (0, getOperationParameterDefault_1.getOperationParameterDefault)(parameter, operationParameter);
+            return operationParameter;
+        }
+    }
+    if ((parameter.type === 'int' || parameter.type === 'integer') && parameter.description) {
+        const enumerators = (0, getEnumFromDescription_1.getEnumFromDescription)(parameter.description);
+        if (enumerators.length) {
+            operationParameter.export = 'enum';
+            operationParameter.type = 'number';
+            operationParameter.base = 'number';
+            operationParameter.enum.push(...enumerators);
+            operationParameter.default = (0, getOperationParameterDefault_1.getOperationParameterDefault)(parameter, operationParameter);
+            return operationParameter;
+        }
+    }
+    if (parameter.type === 'array' && parameter?.items?.type) {
+        const items = this.getType(parameter.items.type, '');
+        operationParameter.export = 'array';
+        operationParameter.type = items.type;
+        operationParameter.base = items.base;
+        operationParameter.template = items.template;
+        operationParameter.imports.push(...items.imports);
+        operationParameter.default = (0, getOperationParameterDefault_1.getOperationParameterDefault)(parameter, operationParameter);
+        return operationParameter;
+    }
+    if (parameter.type === 'object' && parameter?.items?.type) {
+        const items = this.getType(parameter.items.type, '');
+        operationParameter.export = 'dictionary';
+        operationParameter.type = items.type;
+        operationParameter.base = items.base;
+        operationParameter.template = items.template;
+        operationParameter.imports.push(...items.imports);
+        operationParameter.default = (0, getOperationParameterDefault_1.getOperationParameterDefault)(parameter, operationParameter);
+        return operationParameter;
+    }
+    if (parameter.schema) {
+        if (parameter.schema.$ref) {
+            const model = this.getType(parameter.schema.$ref, '');
+            operationParameter.export = 'reference';
+            operationParameter.type = model.type;
+            operationParameter.base = model.base;
+            operationParameter.template = model.template;
+            operationParameter.imports.push(...model.imports);
+            operationParameter.default = (0, getOperationParameterDefault_1.getOperationParameterDefault)(parameter, operationParameter);
+            return operationParameter;
+        }
+        else {
+            const model = this.getModel({ openApi: openApi, definition: parameter.schema, parentRef: '' });
+            operationParameter.export = model.export;
+            operationParameter.type = model.type;
+            operationParameter.base = model.base;
+            operationParameter.template = model.template;
+            operationParameter.link = model.link;
+            operationParameter.imports.push(...model.imports);
+            operationParameter.enum.push(...model.enum);
+            operationParameter.enums.push(...model.enums);
+            operationParameter.properties.push(...model.properties);
+            operationParameter.default = (0, getOperationParameterDefault_1.getOperationParameterDefault)(parameter, operationParameter);
+            return operationParameter;
+        }
+    }
+    // If the parameter has a type than it can be a basic or generic type.
+    if (parameter.type) {
+        const definitionType = this.getType(parameter.type, '');
+        operationParameter.export = 'generic';
+        operationParameter.type = definitionType.type;
+        operationParameter.base = definitionType.base;
+        operationParameter.template = definitionType.template;
+        operationParameter.imports.push(...definitionType.imports);
+        operationParameter.default = (0, getOperationParameterDefault_1.getOperationParameterDefault)(parameter, operationParameter);
+        return operationParameter;
+    }
+    return operationParameter;
+}

package/dist/core/api/v2/parser/getOperationParameterDefault.d.ts

@@ -0,0 +1,4 @@
+import type { OperationParameter } from '../../../types/shared/OperationParameter.model';
+import type { OpenApiParameter } from '../types/OpenApiParameter.model';
+export declare function getOperationParameterDefault(parameter: OpenApiParameter, operationParameter: OperationParameter): string | undefined;
+//# sourceMappingURL=getOperationParameterDefault.d.ts.map

package/dist/core/api/v2/parser/getOperationParameterDefault.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationParameterDefault.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getOperationParameterDefault.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AACzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAExE,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,kBAAkB,GAAG,MAAM,GAAG,SAAS,CAmCpI"}

package/dist/core/api/v2/parser/getOperationParameterDefault.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperationParameterDefault = getOperationParameterDefault;
+function getOperationParameterDefault(parameter, operationParameter) {
+    if (parameter.default === undefined) {
+        return;
+    }
+    if (parameter.default === null) {
+        return 'null';
+    }
+    const type = parameter.type || typeof parameter.default;
+    switch (type) {
+        case 'int':
+        case 'integer':
+        case 'number':
+            if (operationParameter.export === 'enum' && operationParameter.enum?.[parameter.default]) {
+                return operationParameter.enum[parameter.default].value;
+            }
+            return parameter.default;
+        case 'boolean':
+            return JSON.stringify(parameter.default);
+        case 'string':
+            return `'${parameter.default}'`;
+        case 'object':
+            try {
+                return JSON.stringify(parameter.default, null, 4);
+            }
+            catch {
+                // Ignore
+            }
+    }
+    return;
+}

package/dist/core/api/v2/parser/getOperationParameters.d.ts

@@ -0,0 +1,6 @@
+import type { OperationParameters } from '../../../types/shared/OperationParameters.model';
+import { Parser } from '../Parser';
+import type { OpenApi } from '../types/OpenApi.model';
+import type { OpenApiParameter } from '../types/OpenApiParameter.model';
+export declare function getOperationParameters(this: Parser, openApi: OpenApi, parameters: OpenApiParameter[]): OperationParameters;
+//# sourceMappingURL=getOperationParameters.d.ts.map

package/dist/core/api/v2/parser/getOperationParameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationParameters.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getOperationParameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AAE3F,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAExE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,mBAAmB,CA6D1H"}

package/dist/core/api/v2/parser/getOperationParameters.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperationParameters = getOperationParameters;
+const sortByRequired_1 = require("../../../utils/sortByRequired");
+function getOperationParameters(openApi, parameters) {
+    const operationParameters = {
+        imports: [],
+        parameters: [],
+        parametersPath: [],
+        parametersQuery: [],
+        parametersForm: [],
+        parametersCookie: [],
+        parametersHeader: [],
+        parametersBody: null,
+    };
+    // Iterate over the parameters
+    parameters.forEach(parameterOrReference => {
+        const parameterDef = (parameterOrReference.$ref ? this.context.get(parameterOrReference.$ref) : parameterOrReference);
+        const parameter = this.getOperationParameter(openApi, parameterDef);
+        // We ignore the "api-version" param, since we do not want to add this
+        // as the first / default parameter for each of the service calls.
+        if (parameter.prop !== 'api-version') {
+            switch (parameter.in) {
+                case 'path':
+                    operationParameters.parametersPath.push(parameter);
+                    operationParameters.parameters.push(parameter);
+                    operationParameters.imports.push(...parameter.imports);
+                    break;
+                case 'query':
+                    operationParameters.parametersQuery.push(parameter);
+                    operationParameters.parameters.push(parameter);
+                    operationParameters.imports.push(...parameter.imports);
+                    break;
+                case 'header':
+                    operationParameters.parametersHeader.push(parameter);
+                    operationParameters.parameters.push(parameter);
+                    operationParameters.imports.push(...parameter.imports);
+                    break;
+                case 'formData':
+                    operationParameters.parametersForm.push(parameter);
+                    operationParameters.parameters.push(parameter);
+                    operationParameters.imports.push(...parameter.imports);
+                    break;
+                case 'body':
+                    operationParameters.parametersBody = parameter;
+                    operationParameters.parameters.push(parameter);
+                    operationParameters.imports.push(...parameter.imports);
+                    break;
+            }
+        }
+    });
+    operationParameters.parameters = operationParameters.parameters.sort(sortByRequired_1.sortByRequired);
+    operationParameters.parametersPath = operationParameters.parametersPath.sort(sortByRequired_1.sortByRequired);
+    operationParameters.parametersQuery = operationParameters.parametersQuery.sort(sortByRequired_1.sortByRequired);
+    operationParameters.parametersForm = operationParameters.parametersForm.sort(sortByRequired_1.sortByRequired);
+    operationParameters.parametersCookie = operationParameters.parametersCookie.sort(sortByRequired_1.sortByRequired);
+    operationParameters.parametersHeader = operationParameters.parametersHeader.sort(sortByRequired_1.sortByRequired);
+    return operationParameters;
+}

package/dist/core/api/v2/parser/getOperationResponse.d.ts

@@ -0,0 +1,6 @@
+import type { OperationResponse } from '../../../types/shared/OperationResponse.model';
+import { Parser } from '../Parser';
+import type { OpenApi } from '../types/OpenApi.model';
+import type { OpenApiResponse } from '../types/OpenApiResponse.model';
+export declare function getOperationResponse(this: Parser, openApi: OpenApi, response: OpenApiResponse, responseCode: number, parentRef: string): OperationResponse;
+//# sourceMappingURL=getOperationResponse.d.ts.map

package/dist/core/api/v2/parser/getOperationResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationResponse.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getOperationResponse.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAGvF,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEtE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,iBAAiB,CAmF1J"}

package/dist/core/api/v2/parser/getOperationResponse.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperationResponse = getOperationResponse;
+const get_1 = __importDefault(require("lodash-es/get"));
+const getComment_1 = require("../../../utils/getComment");
+const getPattern_1 = require("../../../utils/getPattern");
+function getOperationResponse(openApi, response, responseCode, parentRef) {
+    const operationResponse = {
+        in: 'response',
+        name: '',
+        alias: '',
+        path: '',
+        code: responseCode,
+        description: (0, getComment_1.getComment)(response.description),
+        export: 'generic',
+        type: 'any',
+        base: 'any',
+        template: null,
+        link: null,
+        isDefinition: false,
+        isReadOnly: false,
+        isRequired: false,
+        isNullable: false,
+        imports: [],
+        enum: [],
+        enums: [],
+        properties: [],
+    };
+    // If this response has a schema, then we need to check two things:
+    // if this is a reference then the parameter is just the 'name' of
+    // this reference type. Otherwise it might be a complex schema and
+    // then we need to parse the schema!
+    if (response.schema) {
+        if (response.schema.$ref) {
+            const model = this.getType(response.schema.$ref, parentRef);
+            operationResponse.export = 'reference';
+            operationResponse.type = model.type;
+            operationResponse.base = model.base;
+            operationResponse.template = model.template;
+            operationResponse.imports.push(...model.imports);
+            return operationResponse;
+        }
+        else {
+            const model = this.getModel({ openApi: openApi, definition: response.schema, parentRef: parentRef });
+            operationResponse.export = model.export;
+            operationResponse.type = model.type;
+            operationResponse.base = model.base;
+            operationResponse.template = model.template;
+            operationResponse.link = model.link;
+            operationResponse.isReadOnly = model.isReadOnly;
+            operationResponse.isRequired = model.isRequired;
+            operationResponse.isNullable = model.isNullable;
+            operationResponse.format = model.format;
+            operationResponse.maximum = model.maximum;
+            operationResponse.exclusiveMaximum = model.exclusiveMaximum;
+            operationResponse.minimum = model.minimum;
+            operationResponse.exclusiveMinimum = model.exclusiveMinimum;
+            operationResponse.multipleOf = model.multipleOf;
+            operationResponse.maxLength = model.maxLength;
+            operationResponse.minLength = model.minLength;
+            operationResponse.maxItems = model.maxItems;
+            operationResponse.minItems = model.minItems;
+            operationResponse.uniqueItems = model.uniqueItems;
+            operationResponse.maxProperties = model.maxProperties;
+            operationResponse.minProperties = model.minProperties;
+            operationResponse.pattern = (0, getPattern_1.getPattern)(model.pattern);
+            operationResponse.imports.push(...model.imports);
+            operationResponse.enum.push(...model.enum);
+            operationResponse.enums.push(...model.enums);
+            operationResponse.properties.push(...model.properties);
+            return operationResponse;
+        }
+    }
+    // We support basic properties from response headers, since both
+    // fetch and XHR client just support string types.
+    if (response.headers) {
+        for (const name in response.headers) {
+            if ((0, get_1.default)(response.headers, name, null)) {
+                operationResponse.in = 'header';
+                operationResponse.name = name;
+                operationResponse.type = 'string';
+                operationResponse.base = 'string';
+                return operationResponse;
+            }
+        }
+    }
+    return operationResponse;
+}

package/dist/core/api/v2/parser/getOperationResponses.d.ts

@@ -0,0 +1,6 @@
+import type { OperationResponse } from '../../../types/shared/OperationResponse.model';
+import { Parser } from '../Parser';
+import type { OpenApi } from '../types/OpenApi.model';
+import type { OpenApiResponses } from '../types/OpenApiResponses.model';
+export declare function getOperationResponses(this: Parser, openApi: OpenApi, responses: OpenApiResponses): OperationResponse[];
+//# sourceMappingURL=getOperationResponses.d.ts.map

package/dist/core/api/v2/parser/getOperationResponses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationResponses.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getOperationResponses.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAEvF,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAExE,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,gBAAgB,GAAG,iBAAiB,EAAE,CAsBtH"}

package/dist/core/api/v2/parser/getOperationResponses.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperationResponses = getOperationResponses;
+const get_1 = __importDefault(require("lodash-es/get"));
+const getOperationResponseCode_1 = require("../../../utils/getOperationResponseCode");
+function getOperationResponses(openApi, responses) {
+    const operationResponses = [];
+    // Iterate over each response code and get the
+    // status code and response message (if any).
+    for (const code in responses) {
+        if ((0, get_1.default)(responses, code, null)) {
+            const responseOrReference = responses[code];
+            const response = (responseOrReference.$ref ? this.context.get(responseOrReference.$ref) : responseOrReference);
+            const responseCode = (0, getOperationResponseCode_1.getOperationResponseCode)(code);
+            if (responseCode) {
+                const operationResponse = this.getOperationResponse(openApi, response, responseCode, '');
+                operationResponses.push(operationResponse);
+            }
+        }
+    }
+    // Sort the responses to 2XX success codes come before 4XX and 5XX error codes.
+    return operationResponses.sort((a, b) => {
+        return a.code < b.code ? -1 : a.code > b.code ? 1 : 0;
+    });
+}

package/dist/core/api/v2/parser/getServer.d.ts

@@ -0,0 +1,7 @@
+import type { OpenApi } from '../types/OpenApi.model';
+/**
+ * Get the base server url.
+ * @param openApi
+ */
+export declare function getServer(openApi: OpenApi): string;
+//# sourceMappingURL=getServer.d.ts.map

package/dist/core/api/v2/parser/getServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getServer.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAKlD"}

package/dist/core/api/v2/parser/getServer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServer = getServer;
+/**
+ * Get the base server url.
+ * @param openApi
+ */
+function getServer(openApi) {
+    const scheme = openApi.schemes?.[0] || 'http';
+    const host = openApi.host;
+    const basePath = openApi.basePath || '';
+    return host ? `${scheme}://${host}${basePath}` : basePath;
+}

package/dist/core/api/v2/parser/getServices.d.ts

@@ -0,0 +1,8 @@
+import type { Service } from '../../../types/shared/Service.model';
+import { Parser } from '../Parser';
+import type { OpenApi } from '../types/OpenApi.model';
+/**
+ * Get the OpenAPI services
+ */
+export declare function getServices(this: Parser, openApi: OpenApi): Service[];
+//# sourceMappingURL=getServices.d.ts.map

package/dist/core/api/v2/parser/getServices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getServices.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getServices.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AACnE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,EAAE,CA4CrE"}

package/dist/core/api/v2/parser/getServices.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServices = getServices;
+const get_1 = __importDefault(require("lodash-es/get"));
+/**
+ * Get the OpenAPI services
+ */
+function getServices(openApi) {
+    const services = new Map();
+    for (const url in openApi.paths) {
+        if ((0, get_1.default)(openApi.paths, url, null)) {
+            // Grab path and parse any global path parameters
+            const path = openApi.paths[url];
+            const pathParams = this.getOperationParameters(openApi, path.parameters || []);
+            // Parse all the methods for this path
+            for (const method in path) {
+                if ((0, get_1.default)(path, method, null)) {
+                    switch (method) {
+                        case 'get':
+                        case 'put':
+                        case 'post':
+                        case 'delete':
+                        case 'options':
+                        case 'head':
+                        case 'patch': {
+                            // Each method contains an OpenAPI operation, we parse the operation
+                            const op = path[method];
+                            const operation = this.getOperation(openApi, url, method, op, pathParams);
+                            // If we have already declared a service, then we should fetch that and
+                            // append the new method to it. Otherwise we should create a new service object.
+                            const service = services.get(operation.service) || {
+                                name: operation.service,
+                                originName: operation.service,
+                                operations: [],
+                                imports: [],
+                            };
+                            // Push the operation in the service
+                            service.operations.push(operation);
+                            service.imports.push(...operation.imports);
+                            services.set(operation.service, service);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return Array.from(services.values());
+}

package/dist/core/api/v2/parser/getType.d.ts

@@ -0,0 +1,9 @@
+import type { Type } from '../../../types/shared/Type.model';
+import { Parser } from '../Parser';
+/**
+ * Parse any string value into a type object.
+ * @param value String value like "integer" or "Link[Model]".
+ * @param parentRef Reference to a parent model
+ */
+export declare function getType(this: Parser, value: string, parentRef: string): Type;
+//# sourceMappingURL=getType.d.ts.map

package/dist/core/api/v2/parser/getType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getType.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kCAAkC,CAAC;AAQ7D,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CA8B5E"}

package/dist/core/api/v2/parser/getType.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getType = getType;
+const getAbsolutePath_1 = require("../../../utils/getAbsolutePath");
+const getMappedType_1 = require("../../../utils/getMappedType");
+const getRelativeModelImportPath_1 = require("../../../utils/getRelativeModelImportPath");
+const getRelativeModelPath_1 = require("../../../utils/getRelativeModelPath");
+const getTypeName_1 = require("../../../utils/getTypeName");
+const replaceString_1 = require("../../../utils/replaceString");
+const stripNamespace_1 = require("../../../utils/stripNamespace");
+/**
+ * Parse any string value into a type object.
+ * @param value String value like "integer" or "Link[Model]".
+ * @param parentRef Reference to a parent model
+ */
+function getType(value, parentRef) {
+    const normalizedValue = (0, replaceString_1.replaceString)(value);
+    const result = {
+        type: 'any',
+        base: 'any',
+        template: null,
+        imports: [],
+        path: '',
+    };
+    const valueClean = (0, stripNamespace_1.stripNamespace)(normalizedValue || '');
+    const valuePath = (0, getRelativeModelPath_1.getRelativeModelPath)(this.context.output?.outputModels, valueClean);
+    if ((0, getMappedType_1.hasMappedType)(valueClean)) {
+        const mapped = (0, getMappedType_1.getMappedType)(valueClean);
+        result.path = valuePath;
+        if (mapped) {
+            result.type = mapped;
+            result.base = mapped;
+        }
+    }
+    else if (valueClean) {
+        const valueImportPath = (0, getRelativeModelImportPath_1.getRelativeModelImportPath)(this.context.output.outputModels, parentRef, valueClean);
+        const type = this.getTypeNameByRef((0, getTypeName_1.getTypeName)(valueClean), (0, getAbsolutePath_1.getAbsolutePath)(value, parentRef));
+        result.path = valuePath;
+        result.type = type;
+        result.base = type;
+        result.imports.push({ name: type, alias: '', path: valueImportPath });
+    }
+    return result;
+}

package/dist/core/api/v2/parserV2.d.ts

@@ -0,0 +1,11 @@
+import type { Client } from '../../types/shared/Client.model';
+import { Parser } from './Parser';
+import type { OpenApi } from './types/OpenApi.model';
+/**
+ * Parse the OpenAPI specification to a Client model that contains
+ * all the models, services and schema's we should output.
+ * @param context The context of application
+ * @param openApi The OpenAPI spec  that we have loaded from disk.
+ */
+export declare function parse(this: Parser, openApi: OpenApi): Client;
+//# sourceMappingURL=parserV2.d.ts.map

package/dist/core/api/v2/parserV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parserV2.d.ts","sourceRoot":"","sources":["../../../../src/core/api/v2/parserV2.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAE9D,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAO5D"}