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

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

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = getModel;
+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 getPattern_1 = require("../../../utils/getPattern");
+const getModelDefault_1 = require("./getModelDefault");
+function getModel(config) {
+    const { openApi, definition, isDefinition = false, name = '', path = '', parentRef } = config;
+    const model = {
+        name,
+        alias: '',
+        path,
+        export: 'interface',
+        type: 'any',
+        base: 'any',
+        link: null,
+        template: null,
+        description: (0, getComment_1.getComment)(definition.description),
+        isDefinition,
+        isReadOnly: definition.readOnly === true,
+        isNullable: definition.nullable === true,
+        isRequired: definition.default !== undefined,
+        format: definition.format,
+        maximum: definition.maximum,
+        exclusiveMaximum: definition.exclusiveMaximum,
+        minimum: definition.minimum,
+        exclusiveMinimum: definition.exclusiveMinimum,
+        multipleOf: definition.multipleOf,
+        maxLength: definition.maxLength,
+        minLength: definition.minLength,
+        maxItems: definition.maxItems,
+        minItems: definition.minItems,
+        uniqueItems: definition.uniqueItems,
+        maxProperties: definition.maxProperties,
+        minProperties: definition.minProperties,
+        pattern: (0, getPattern_1.getPattern)(definition.pattern),
+        imports: [],
+        enum: [],
+        enums: [],
+        properties: [],
+    };
+    if (definition.$ref) {
+        const definitionRef = this.getType(definition.$ref, parentRef);
+        model.export = 'reference';
+        model.type = definitionRef.type;
+        model.base = definitionRef.base;
+        model.imports.push(...definitionRef.imports);
+        model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
+        return model;
+    }
+    if (definition.enum && definition.type !== 'boolean') {
+        const enumerators = (0, getEnum_1.getEnum)(definition.enum);
+        const extendedEnumerators = (0, extendEnum_1.extendEnum)(enumerators, definition);
+        if (extendedEnumerators.length) {
+            model.export = 'enum';
+            model.type = 'string';
+            model.base = 'string';
+            model.enum.push(...extendedEnumerators);
+            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
+            return model;
+        }
+    }
+    if ((definition.type === 'int' || definition.type === 'integer') && definition.description) {
+        const enumerators = (0, getEnumFromDescription_1.getEnumFromDescription)(definition.description);
+        if (enumerators.length) {
+            model.export = 'enum';
+            model.type = 'number';
+            model.base = 'number';
+            model.enum.push(...enumerators);
+            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
+            return model;
+        }
+    }
+    if (definition.type === 'array' && definition.items) {
+        if (definition.items.$ref) {
+            const arrayItems = this.getType(definition.items.$ref, parentRef);
+            model.export = 'array';
+            model.type = arrayItems.type;
+            model.base = arrayItems.base;
+            model.imports.push(...arrayItems.imports);
+            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
+            return model;
+        }
+        else {
+            const arrayItems = this.getModel({ openApi: openApi, definition: definition.items, parentRef: parentRef });
+            model.export = 'array';
+            model.type = arrayItems.type;
+            model.base = arrayItems.base;
+            model.link = arrayItems;
+            model.imports.push(...arrayItems.imports);
+            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
+            return model;
+        }
+    }
+    if (definition.type === 'object' && typeof definition.additionalProperties === 'object') {
+        if (definition.additionalProperties.$ref) {
+            const additionalProperties = this.getType(definition.additionalProperties.$ref, parentRef);
+            model.export = 'dictionary';
+            model.type = additionalProperties.type;
+            model.base = additionalProperties.base;
+            model.imports.push(...additionalProperties.imports);
+            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
+            return model;
+        }
+        else {
+            const additionalProperties = this.getModel({
+                openApi: openApi,
+                definition: definition.additionalProperties,
+                parentRef: parentRef,
+            });
+            model.export = 'dictionary';
+            model.type = additionalProperties.type;
+            model.base = additionalProperties.base;
+            model.link = additionalProperties;
+            model.imports.push(...additionalProperties.imports);
+            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
+            return model;
+        }
+    }
+    if (definition.oneOf?.length) {
+        const composition = this.getModelComposition(openApi, definition, definition.oneOf, 'one-of', parentRef);
+        model.export = composition.type;
+        model.imports.push(...composition.imports);
+        model.properties.push(...composition.properties);
+        model.enums.push(...composition.enums);
+        return model;
+    }
+    if (definition.anyOf?.length) {
+        const composition = this.getModelComposition(openApi, definition, definition.anyOf, 'any-of', parentRef);
+        model.export = composition.type;
+        model.imports.push(...composition.imports);
+        model.properties.push(...composition.properties);
+        model.enums.push(...composition.enums);
+        return model;
+    }
+    if (definition.allOf?.length) {
+        const composition = this.getModelComposition(openApi, definition, definition.allOf, 'all-of', parentRef);
+        model.export = composition.type;
+        model.imports.push(...composition.imports);
+        model.properties.push(...composition.properties);
+        model.enums.push(...composition.enums);
+        return model;
+    }
+    if (definition.type === 'object') {
+        model.export = 'interface';
+        model.type = 'any';
+        model.base = 'any';
+        model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
+        if (definition.properties) {
+            const properties = this.getModelProperties(openApi, definition, parentRef);
+            properties.forEach(property => {
+                model.imports.push(...property.imports);
+                model.enums.push(...property.enums);
+                model.properties.push(property);
+                if (property.export === 'enum') {
+                    model.enums.push(property);
+                }
+            });
+        }
+        return model;
+    }
+    // If the schema has a type than it can be a basic or generic type.
+    if (definition.type) {
+        const definitionType = this.getType(definition.type, parentRef);
+        model.export = 'generic';
+        model.type = definitionType.type;
+        model.base = definitionType.base;
+        model.imports.push(...definitionType.imports);
+        model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
+        return model;
+    }
+    return model;
+}

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

@@ -0,0 +1,6 @@
+import type { ModelComposition } from '../../../types/shared/ModelComposition.model';
+import { Parser } from '../Parser';
+import type { OpenApi } from '../types/OpenApi.model';
+import type { OpenApiSchema } from '../types/OpenApiSchema.model';
+export declare function getModelComposition(this: Parser, openApi: OpenApi, definition: OpenApiSchema, definitions: OpenApiSchema[], type: 'one-of' | 'any-of' | 'all-of', parentRef: string): ModelComposition;
+//# sourceMappingURL=getModelComposition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getModelComposition.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v3/parser/getModelComposition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAErF,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,aAAa,EACzB,WAAW,EAAE,aAAa,EAAE,EAC5B,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,EACpC,SAAS,EAAE,MAAM,GAClB,gBAAgB,CAyDlB"}

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelComposition = getModelComposition;
+const unique_1 = require("../../../utils/unique");
+function getModelComposition(openApi, definition, definitions, type, parentRef) {
+    const composition = {
+        type,
+        imports: [],
+        enums: [],
+        properties: [],
+    };
+    const models = definitions.map(definition => this.getModel({
+        openApi: openApi,
+        definition: definition,
+        parentRef: parentRef,
+    }));
+    models
+        .filter(model => {
+        const hasProperties = model.properties.length;
+        const hasEnums = model.enums.length;
+        const isObject = model.type === 'any';
+        const isEmpty = isObject && !hasProperties && !hasEnums;
+        return !isEmpty;
+    })
+        .forEach(model => {
+        composition.imports.push(...model.imports);
+        composition.enums.push(...model.enums);
+        composition.properties.push(model);
+    });
+    if (definition.properties) {
+        const properties = this.getModelProperties(openApi, definition, parentRef);
+        properties.forEach(property => {
+            composition.imports.push(...property.imports);
+            composition.enums.push(...property.enums);
+        });
+        composition.properties.push({
+            name: 'properties',
+            alias: '',
+            path: '',
+            export: 'interface',
+            type: 'any',
+            base: 'any',
+            template: null,
+            link: null,
+            description: '',
+            isDefinition: false,
+            isReadOnly: false,
+            isNullable: false,
+            isRequired: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties,
+        });
+    }
+    composition.imports = composition.imports.filter(unique_1.unique);
+    return composition;
+}

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

@@ -0,0 +1,4 @@
+import type { Model } from '../../../types/shared/Model.model';
+import type { OpenApiSchema } from '../types/OpenApiSchema.model';
+export declare function getModelDefault(definition: OpenApiSchema, model?: Model): string | undefined;
+//# sourceMappingURL=getModelDefault.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getModelDefault.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v3/parser/getModelDefault.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,wBAAgB,eAAe,CAAC,UAAU,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CAmC5F"}

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

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

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

@@ -0,0 +1,6 @@
+import type { Model } from '../../../types/shared/Model.model';
+import { Parser } from '../Parser';
+import type { OpenApi } from '../types/OpenApi.model';
+import type { OpenApiSchema } from '../types/OpenApiSchema.model';
+export declare function getModelProperties(this: Parser, openApi: OpenApi, definition: OpenApiSchema, parentRef: string): Model[];
+//# sourceMappingURL=getModelProperties.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getModelProperties.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v3/parser/getModelProperties.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAK/D,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,EAAE,CAiFxH"}

package/dist/core/api/v3/parser/getModelProperties.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.getModelProperties = getModelProperties;
+const get_1 = __importDefault(require("lodash-es/get"));
+const escapeName_1 = require("../../../utils/escapeName");
+const getClassName_1 = require("../../../utils/getClassName");
+const getComment_1 = require("../../../utils/getComment");
+const getPattern_1 = require("../../../utils/getPattern");
+function getModelProperties(openApi, definition, parentRef) {
+    const models = [];
+    for (const propertyName in definition.properties) {
+        if ((0, get_1.default)(definition.properties, propertyName, null)) {
+            const property = definition.properties[propertyName];
+            const propertyRequired = definition.required?.includes(propertyName) || property.default !== undefined;
+            if (property.$ref) {
+                const model = this.getType(property.$ref, parentRef);
+                models.push({
+                    name: (0, escapeName_1.escapeName)(propertyName),
+                    alias: '',
+                    path: model.path,
+                    export: 'reference',
+                    type: model.type,
+                    base: model.base,
+                    template: model.template,
+                    link: null,
+                    description: (0, getComment_1.getComment)(property.description),
+                    isDefinition: false,
+                    isReadOnly: property.readOnly === true,
+                    isRequired: propertyRequired,
+                    isNullable: property.nullable === true,
+                    format: property.format,
+                    maximum: property.maximum,
+                    exclusiveMaximum: property.exclusiveMaximum,
+                    minimum: property.minimum,
+                    exclusiveMinimum: property.exclusiveMinimum,
+                    multipleOf: property.multipleOf,
+                    maxLength: property.maxLength,
+                    minLength: property.minLength,
+                    maxItems: property.maxItems,
+                    minItems: property.minItems,
+                    uniqueItems: property.uniqueItems,
+                    maxProperties: property.maxProperties,
+                    minProperties: property.minProperties,
+                    pattern: (0, getPattern_1.getPattern)(property.pattern),
+                    imports: model.imports,
+                    enum: [],
+                    enums: [],
+                    properties: [],
+                });
+            }
+            else {
+                const model = this.getModel({ openApi: openApi, definition: property, parentRef: parentRef });
+                models.push({
+                    name: (0, escapeName_1.escapeName)(propertyName),
+                    alias: model.export === 'enum' ? `${this.context.prefix.enum}${(0, getClassName_1.getClassName)((0, escapeName_1.escapeName)(propertyName))}` : '',
+                    path: model.path,
+                    export: model.export,
+                    type: model.type,
+                    base: model.base,
+                    template: model.template,
+                    link: model.link,
+                    description: (0, getComment_1.getComment)(property.description),
+                    isDefinition: false,
+                    isReadOnly: property.readOnly === true,
+                    isRequired: propertyRequired,
+                    isNullable: property.nullable === true,
+                    format: property.format,
+                    maximum: property.maximum,
+                    exclusiveMaximum: property.exclusiveMaximum,
+                    minimum: property.minimum,
+                    exclusiveMinimum: property.exclusiveMinimum,
+                    multipleOf: property.multipleOf,
+                    maxLength: property.maxLength,
+                    minLength: property.minLength,
+                    maxItems: property.maxItems,
+                    minItems: property.minItems,
+                    uniqueItems: property.uniqueItems,
+                    maxProperties: property.maxProperties,
+                    minProperties: property.minProperties,
+                    pattern: (0, getPattern_1.getPattern)(property.pattern),
+                    imports: model.imports,
+                    enum: model.enum,
+                    enums: model.enums,
+                    properties: model.properties,
+                });
+            }
+        }
+    }
+    return models;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getModels.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v3/parser/getModels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAK/D,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,KAAK,EAAE,CA+CjE"}

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"}