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

package/dist/core/api/v3/parser/getModels.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModels = getModels;
+const getRefFromSchema_1 = require("../../../utils/getRefFromSchema");
+const pathHelpers_1 = require("../../../utils/pathHelpers");
+const sortModelsByName_1 = require("../../../utils/sortModelsByName");
+const unique_1 = require("../../../utils/unique");
+function getModels(openApi) {
+    let models = [];
+    const listOfModelsRef = (0, getRefFromSchema_1.getRefFromSchema)(this.context, openApi);
+    if (listOfModelsRef) {
+        for (const modelRef of listOfModelsRef) {
+            const definition = this.context.get(modelRef);
+            const definitionType = this.getType(modelRef, '');
+            const model = this.getModel({
+                openApi: openApi,
+                definition: definition,
+                isDefinition: true,
+                name: definitionType.base,
+                path: definitionType.path,
+                parentRef: modelRef,
+            });
+            models.push(model);
+        }
+        models = (0, sortModelsByName_1.sortModelsByName)(models.filter(unique_1.unique));
+        let previous;
+        let index = 1;
+        models.forEach(model => {
+            if (previous && previous.name === model.name) {
+                if (index === 1) {
+                    previous.alias = `${model.name}$${index}`;
+                    index++;
+                }
+                model.alias = `${model.name}$${index}`;
+                index++;
+            }
+            else {
+                model.alias = '';
+                index = 1;
+            }
+            previous = model;
+        });
+        models.forEach(model => {
+            model.imports = model.imports.map(imprt => {
+                const importModel = models.filter(value => `${value.path}${value.name}` === imprt.path && value.name === imprt.name);
+                const importAlias = importModel.length > 0 ? importModel[0].alias : imprt?.alias;
+                const importPath = importModel.length > 0 ? (0, pathHelpers_1.join)((0, pathHelpers_1.relative)(model.path, importModel[0].path), imprt.name) : imprt.path;
+                return Object.assign(imprt, {
+                    alias: importAlias,
+                    path: importPath,
+                });
+            });
+        });
+    }
+    return models.filter(unique_1.unique);
+}

package/dist/core/api/v3/parser/getOperation.d.ts

@@ -0,0 +1,7 @@
+import type { Operation } from '../../../types/shared/Operation.model';
+import type { OperationParameters } from '../../../types/shared/OperationParameters.model';
+import { Parser } from '../Parser';
+import type { OpenApi } from '../types/OpenApi.model';
+import type { OpenApiOperation } from '../types/OpenApiOperation.model';
+export declare function getOperation(this: Parser, openApi: OpenApi, url: string, method: string, op: OpenApiOperation, pathParams: OperationParameters, serviceClassName: string): Operation;
+//# sourceMappingURL=getOperation.d.ts.map

package/dist/core/api/v3/parser/getOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperation.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v3/parser/getOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AACvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AAQ3F,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,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,gBAAgB,EAAE,UAAU,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,GAAG,SAAS,CA+DpL"}

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

@@ -0,0 +1,68 @@
+"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 sortByRequired_1 = require("../../../utils/sortByRequired");
+function getOperation(openApi, url, method, op, pathParams, serviceClassName) {
+    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;
+    }
+    if (op.requestBody) {
+        const requestBodyDef = (op.requestBody.$ref ? this.context.get(op.requestBody.$ref) : op.requestBody);
+        const requestBody = this.getOperationRequestBody(openApi, requestBodyDef, '');
+        operation.imports.push(...requestBody.imports);
+        operation.parameters.push(requestBody);
+        operation.parameters = operation.parameters.sort(sortByRequired_1.sortByRequired);
+        operation.parametersBody = requestBody;
+    }
+    // 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/v3/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/v3/parser/getOperationParameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationParameter.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v3/parser/getOperationParameter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AAIzF,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,CA8ErH"}

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperationParameter = getOperationParameter;
+const getComment_1 = require("../../../utils/getComment");
+const getOperationParameterName_1 = require("../../../utils/getOperationParameterName");
+const getPattern_1 = require("../../../utils/getPattern");
+const getModelDefault_1 = require("./getModelDefault");
+function getOperationParameter(openApi, parameter) {
+    const operationParameter = {
+        in: parameter.in,
+        prop: parameter.name,
+        export: 'interface',
+        name: (0, getOperationParameterName_1.getOperationParameterName)(parameter.name),
+        alias: '',
+        path: '',
+        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.nullable === true,
+        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);
+        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, getModelDefault_1.getModelDefault)(parameter.schema);
+            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.isReadOnly = model.isReadOnly;
+            operationParameter.isRequired = operationParameter.isRequired || model.isRequired;
+            operationParameter.isNullable = operationParameter.isNullable || model.isNullable;
+            operationParameter.format = model.format;
+            operationParameter.maximum = model.maximum;
+            operationParameter.exclusiveMaximum = model.exclusiveMaximum;
+            operationParameter.minimum = model.minimum;
+            operationParameter.exclusiveMinimum = model.exclusiveMinimum;
+            operationParameter.multipleOf = model.multipleOf;
+            operationParameter.maxLength = model.maxLength;
+            operationParameter.minLength = model.minLength;
+            operationParameter.maxItems = model.maxItems;
+            operationParameter.minItems = model.minItems;
+            operationParameter.uniqueItems = model.uniqueItems;
+            operationParameter.maxProperties = model.maxProperties;
+            operationParameter.minProperties = model.minProperties;
+            operationParameter.pattern = (0, getPattern_1.getPattern)(model.pattern);
+            operationParameter.default = model.default;
+            operationParameter.imports.push(...model.imports);
+            operationParameter.enum.push(...model.enum);
+            operationParameter.enums.push(...model.enums);
+            operationParameter.properties.push(...model.properties);
+            return operationParameter;
+        }
+    }
+    return operationParameter;
+}

package/dist/core/api/v3/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/v3/parser/getOperationParameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationParameters.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v3/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/v3/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, // Not used in V3 -> @see requestBody
+    };
+    // 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 (parameterDef.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 'formData':
+                    operationParameters.parametersForm.push(parameter);
+                    operationParameters.parameters.push(parameter);
+                    operationParameters.imports.push(...parameter.imports);
+                    break;
+                case 'cookie':
+                    operationParameters.parametersCookie.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;
+            }
+        }
+    });
+    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/v3/parser/getOperationRequestBody.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 { OpenApiRequestBody } from '../types/OpenApiRequestBody.model';
+export declare function getOperationRequestBody(this: Parser, openApi: OpenApi, parameter: OpenApiRequestBody, parentRef: string): OperationParameter;
+//# sourceMappingURL=getOperationRequestBody.d.ts.map

package/dist/core/api/v3/parser/getOperationRequestBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationRequestBody.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v3/parser/getOperationRequestBody.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AAGzF,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAG5E,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,GAAG,kBAAkB,CA6E5I"}

package/dist/core/api/v3/parser/getOperationRequestBody.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperationRequestBody = getOperationRequestBody;
+const getComment_1 = require("../../../utils/getComment");
+const getPattern_1 = require("../../../utils/getPattern");
+const getContent_1 = require("./getContent");
+function getOperationRequestBody(openApi, parameter, parentRef) {
+    const requestBody = {
+        in: 'body',
+        prop: 'body',
+        export: 'interface',
+        name: 'requestBody',
+        alias: '',
+        path: '',
+        type: 'any',
+        base: 'any',
+        template: null,
+        link: null,
+        description: (0, getComment_1.getComment)(parameter.description),
+        default: undefined,
+        isDefinition: false,
+        isReadOnly: false,
+        isRequired: parameter.required === true,
+        isNullable: parameter.nullable === true,
+        imports: [],
+        enum: [],
+        enums: [],
+        properties: [],
+        mediaType: null,
+    };
+    if (parameter.content) {
+        const content = (0, getContent_1.getContent)(parameter.content);
+        if (content) {
+            requestBody.mediaType = content.mediaType;
+            if (requestBody.mediaType === 'multipart/form-data') {
+                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                (requestBody.in = 'formData'), (requestBody.name = 'formData'), (requestBody.prop = 'formData');
+            }
+            if (content?.schema?.$ref) {
+                const model = this.getType(content.schema.$ref, parentRef);
+                requestBody.export = 'reference';
+                requestBody.type = model.type;
+                requestBody.base = model.base;
+                requestBody.path = model.path;
+                requestBody.template = model.template;
+                requestBody.imports.push(...model.imports);
+                return requestBody;
+            }
+            else {
+                const model = this.getModel({ openApi: openApi, definition: content.schema, parentRef: parentRef });
+                requestBody.export = model.export;
+                requestBody.type = model.type;
+                requestBody.base = model.base;
+                requestBody.path = model.path;
+                requestBody.template = model.template;
+                requestBody.link = model.link;
+                requestBody.isReadOnly = model.isReadOnly;
+                requestBody.isRequired = requestBody.isRequired || model.isRequired;
+                requestBody.isNullable = requestBody.isNullable || model.isNullable;
+                requestBody.format = model.format;
+                requestBody.maximum = model.maximum;
+                requestBody.exclusiveMaximum = model.exclusiveMaximum;
+                requestBody.minimum = model.minimum;
+                requestBody.exclusiveMinimum = model.exclusiveMinimum;
+                requestBody.multipleOf = model.multipleOf;
+                requestBody.maxLength = model.maxLength;
+                requestBody.minLength = model.minLength;
+                requestBody.maxItems = model.maxItems;
+                requestBody.minItems = model.minItems;
+                requestBody.uniqueItems = model.uniqueItems;
+                requestBody.maxProperties = model.maxProperties;
+                requestBody.minProperties = model.minProperties;
+                requestBody.pattern = (0, getPattern_1.getPattern)(model.pattern);
+                requestBody.imports.push(...model.imports);
+                requestBody.enum.push(...model.enum);
+                requestBody.enums.push(...model.enums);
+                requestBody.properties.push(...model.properties);
+                return requestBody;
+            }
+        }
+    }
+    return requestBody;
+}

package/dist/core/api/v3/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/v3/parser/getOperationResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationResponse.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v3/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;AAGtE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,iBAAiB,CAoF1J"}

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

@@ -0,0 +1,93 @@
+"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");
+const getContent_1 = require("./getContent");
+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 (response.content) {
+        const content = (0, getContent_1.getContent)(response.content);
+        if (content) {
+            if (content?.schema?.$ref) {
+                const model = this.getType(content.schema.$ref, parentRef);
+                operationResponse.export = 'reference';
+                operationResponse.type = model.type;
+                operationResponse.base = model.base;
+                operationResponse.path = model.path;
+                operationResponse.template = model.template;
+                operationResponse.imports.push(...model.imports);
+                return operationResponse;
+            }
+            else {
+                const model = this.getModel({ openApi: openApi, definition: content.schema, parentRef: parentRef });
+                operationResponse.export = model.export;
+                operationResponse.type = model.type;
+                operationResponse.base = model.base;
+                operationResponse.path = model.path;
+                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/v3/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/v3/parser/getOperationResponses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationResponses.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v3/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/v3/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/v3/parser/getServer.d.ts

@@ -0,0 +1,3 @@
+import type { OpenApi } from '../types/OpenApi.model';
+export declare function getServer(openApi: OpenApi): string;
+//# sourceMappingURL=getServer.d.ts.map

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServer = getServer;
+const get_1 = __importDefault(require("lodash-es/get"));
+function getServer(openApi) {
+    const server = openApi.servers?.[0];
+    const variables = server?.variables || {};
+    let url = server?.url || '';
+    for (const variable in variables) {
+        if ((0, get_1.default)(variables, variable, null)) {
+            url = url.replace(`{${variable}}`, variables[variable].default);
+        }
+    }
+    return url;
+}

package/dist/core/api/v3/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/v3/parser/getServices.d.ts.map

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