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

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

@@ -0,0 +1,32 @@
+import { Context } from '../../Context';
+import { getModel } from '../v2/parser/getModel';
+import { getModelComposition } from './parser/getModelComposition';
+import { getModelProperties } from './parser/getModelProperties';
+import { getModels } from './parser/getModels';
+import { getOperation } from './parser/getOperation';
+import { getOperationParameter } from './parser/getOperationParameter';
+import { getOperationParameters } from './parser/getOperationParameters';
+import { getOperationResponse } from './parser/getOperationResponse';
+import { getOperationResponses } from './parser/getOperationResponses';
+import { getServices } from './parser/getServices';
+import { getType } from './parser/getType';
+import { parse } from './parserV2';
+export declare class Parser {
+    _context: Context;
+    constructor(context: Context);
+    get context(): Context;
+    getTypeNameByRef(value: string, ref?: string): string;
+    parse: typeof parse;
+    getModels: typeof getModels;
+    getType: typeof getType;
+    getModel: typeof getModel;
+    getModelComposition: typeof getModelComposition;
+    getModelProperties: typeof getModelProperties;
+    getServices: typeof getServices;
+    getOperationParameters: typeof getOperationParameters;
+    getOperationParameter: typeof getOperationParameter;
+    getOperation: typeof getOperation;
+    getOperationResponses: typeof getOperationResponses;
+    getOperationResponse: typeof getOperationResponse;
+}
+//# sourceMappingURL=Parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Parser.d.ts","sourceRoot":"","sources":["../../../../src/core/api/v2/Parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,qBAAa,MAAM;IACR,QAAQ,EAAE,OAAO,CAAC;gBAEb,OAAO,EAAE,OAAO;IAI5B,IAAI,OAAO,IAAI,OAAO,CAErB;IAEM,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM;IAcrD,KAAK,eAAS;IACd,SAAS,mBAAa;IACtB,OAAO,iBAAW;IAClB,QAAQ,kBAAY;IACpB,mBAAmB,6BAAuB;IAC1C,kBAAkB,4BAAsB;IACxC,WAAW,qBAAe;IAC1B,sBAAsB,gCAA0B;IAChD,qBAAqB,+BAAyB;IAC9C,YAAY,sBAAgB;IAC5B,qBAAqB,+BAAyB;IAC9C,oBAAoB,8BAAwB;CACtD"}

package/dist/core/api/v2/Parser.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const getModel_1 = require("../v2/parser/getModel");
+const getModelComposition_1 = require("./parser/getModelComposition");
+const getModelProperties_1 = require("./parser/getModelProperties");
+const getModels_1 = require("./parser/getModels");
+const getOperation_1 = require("./parser/getOperation");
+const getOperationParameter_1 = require("./parser/getOperationParameter");
+const getOperationParameters_1 = require("./parser/getOperationParameters");
+const getOperationResponse_1 = require("./parser/getOperationResponse");
+const getOperationResponses_1 = require("./parser/getOperationResponses");
+const getServices_1 = require("./parser/getServices");
+const getType_1 = require("./parser/getType");
+const parserV2_1 = require("./parserV2");
+class Parser {
+    _context;
+    constructor(context) {
+        this._context = context;
+    }
+    get context() {
+        return this._context;
+    }
+    getTypeNameByRef(value, ref) {
+        if (ref) {
+            const definition = this.context.get(ref);
+            if (definition.oneOf || definition.anyOf || definition.allOf || ['string', 'number', 'integer', 'boolean', 'array'].includes(definition.type)) {
+                return `${this.context.prefix.type}${value}`;
+            }
+            else if (definition.enum && definition !== 'boolean') {
+                return `${this.context.prefix.enum}${value}`;
+            }
+            else if (definition.type === 'object') {
+                return `${this.context.prefix.interface}${value}`;
+            }
+        }
+        return value;
+    }
+    parse = parserV2_1.parse;
+    getModels = getModels_1.getModels;
+    getType = getType_1.getType;
+    getModel = getModel_1.getModel;
+    getModelComposition = getModelComposition_1.getModelComposition;
+    getModelProperties = getModelProperties_1.getModelProperties;
+    getServices = getServices_1.getServices;
+    getOperationParameters = getOperationParameters_1.getOperationParameters;
+    getOperationParameter = getOperationParameter_1.getOperationParameter;
+    getOperation = getOperation_1.getOperation;
+    getOperationResponses = getOperationResponses_1.getOperationResponses;
+    getOperationResponse = getOperationResponse_1.getOperationResponse;
+}
+exports.Parser = Parser;

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getServer.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getServer.test.d.ts","sourceRoot":"","sources":["../../../../../../src/core/api/v2/parser/__tests__/getServer.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const getServer_1 = require("../getServer");
+(0, node_test_1.describe)('getServer', () => {
+    (0, node_test_1.test)('@unit: should produce correct result', () => {
+        node_assert_1.default.strictEqual((0, getServer_1.getServer)({
+            swagger: '2.0',
+            info: {
+                title: 'dummy',
+                version: '1.0',
+            },
+            host: 'localhost:8080',
+            basePath: '/api',
+            schemes: ['http', 'https'],
+            paths: {},
+        }), 'http://localhost:8080/api');
+    });
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getType.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getType.test.d.ts","sourceRoot":"","sources":["../../../../../../src/core/api/v2/parser/__tests__/getType.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const json_schema_ref_parser_1 = __importDefault(require("json-schema-ref-parser"));
+const Context_1 = require("../../../../Context");
+const getOutputPaths_1 = require("../../../../utils/getOutputPaths");
+const Parser_1 = require("../../Parser");
+(0, node_test_1.describe)('getType', () => {
+    (0, node_test_1.test)('@unit: should convert int', async () => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const parser = new json_schema_ref_parser_1.default();
+        const context = new Context_1.Context('test/spec/v3.yml', (0, getOutputPaths_1.getOutputPaths)({ output: './generated' }));
+        context.addRefs(await parser.resolve('test/spec/v3.yml'));
+        const type = new Parser_1.Parser(context).getType('int', '');
+        node_assert_1.default.strictEqual(type.type, 'number');
+        node_assert_1.default.strictEqual(type.base, 'number');
+        node_assert_1.default.strictEqual(type.template, null);
+        node_assert_1.default.deepStrictEqual(type.imports, []);
+    });
+    (0, node_test_1.test)('@unit: should support file with ext', async () => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const parser = new json_schema_ref_parser_1.default();
+        const context = new Context_1.Context('test/spec/v3.yml', (0, getOutputPaths_1.getOutputPaths)({ output: './generated' }));
+        context.addRefs(await parser.resolve('test/spec/v3.yml'));
+        const type = new Parser_1.Parser(context).getType('schemas/ModelWithString.yml', '');
+        node_assert_1.default.strictEqual(type.type, 'IModelWithString');
+        node_assert_1.default.strictEqual(type.base, 'IModelWithString');
+        node_assert_1.default.strictEqual(type.template, null);
+        node_assert_1.default.deepStrictEqual(type.imports, [
+            {
+                name: 'IModelWithString',
+                alias: '',
+                path: './schemas/ModelWithString',
+            },
+        ]);
+    });
+    const object = {
+        components: {
+            schemas: {
+                someSpecialSchema: {
+                    type: 'object',
+                },
+            },
+        },
+    };
+    (0, node_test_1.test)('@unit: should support external generation type', async () => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const parser = new json_schema_ref_parser_1.default();
+        const context = new Context_1.Context(object, (0, getOutputPaths_1.getOutputPaths)({ output: './generated' }));
+        context.addRefs(await parser.resolve(object));
+        const type = new Parser_1.Parser(context).getType('#/components/schemas/someSpecialSchema', '');
+        node_assert_1.default.strictEqual(type.type, 'ISomeSpecialSchema');
+    });
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getModel.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getModel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAM/D,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,KAAK,CAyJjE"}

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

@@ -0,0 +1,154 @@
+"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");
+function getModel(config) {
+    const { openApi, definition, isDefinition = false, name = '', path = '', parentRef } = config;
+    const model = {
+        name,
+        path,
+        alias: '',
+        export: 'interface',
+        type: 'any',
+        base: 'any',
+        template: null,
+        link: null,
+        description: (0, getComment_1.getComment)(definition.description),
+        isDefinition,
+        isReadOnly: definition.readOnly === true,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        isNullable: definition['x-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.template = definitionRef.template;
+        model.imports.push(...definitionRef.imports);
+        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);
+            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);
+            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.template = arrayItems.template;
+            model.imports.push(...arrayItems.imports);
+            return model;
+        }
+        else {
+            const arrayItems = this.getModel({ openApi: openApi, definition: definition.items, parentRef });
+            model.export = 'array';
+            model.type = arrayItems.type;
+            model.base = arrayItems.base;
+            model.template = arrayItems.template;
+            model.link = arrayItems;
+            model.imports.push(...arrayItems.imports);
+            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.template = additionalProperties.template;
+            model.imports.push(...additionalProperties.imports);
+            return model;
+        }
+        else {
+            const additionalProperties = this.getModel({ openApi: openApi, definition: definition.additionalProperties, parentRef });
+            model.export = 'dictionary';
+            model.type = additionalProperties.type;
+            model.base = additionalProperties.base;
+            model.template = additionalProperties.template;
+            model.link = additionalProperties;
+            model.imports.push(...additionalProperties.imports);
+            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';
+        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.template = definitionType.template;
+        model.imports.push(...definitionType.imports);
+        return model;
+    }
+    return model;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"getModelComposition.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getModelComposition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,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,CAkDlB"}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelComposition = getModelComposition;
+function getModelComposition(openApi, definition, definitions, type, parentRef) {
+    const composition = {
+        type,
+        imports: [],
+        enums: [],
+        properties: [],
+    };
+    const models = definitions.map(definition => this.getModel({ openApi, definition, 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,
+        });
+    }
+    return composition;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"getModelProperties.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getModelProperties.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAI/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,CAgFxH"}

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

@@ -0,0 +1,92 @@
+"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 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: '',
+                    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['x-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, definition: property, parentRef });
+                models.push({
+                    name: (0, escapeName_1.escapeName)(propertyName),
+                    alias: '',
+                    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['x-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/v2/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/v2/parser/getModels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getModels.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/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/v2/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/v2/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): Operation;
+//# sourceMappingURL=getOperation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getOperation.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/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;AAExE,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,GAAG,SAAS,CAwD1J"}