ts-openapi-codegen 2.0.0 → 2.1.0-beta.2

package/dist/common/VersionedSchema/CommonSchemas.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.experimentalParametersSchemaV2 = exports.experimentalParametersSchema = exports.additionalParametersSchemaV2 = exports.additionalParametersSchema = exports.specialParametersSchemasV4 = exports.specialParametersSchemasV3 = exports.specialParametersSchemasV2 = exports.specialParametersSchemas = exports.outputPathsSchema = void 0;
+exports.experimentalParametersSchemaV2 = exports.experimentalParametersSchema = exports.additionalParametersSchemaV2 = exports.miraclesConfigSchema = exports.analyzeConfigSchema = exports.modelsConfigSchema = exports.additionalParametersSchema = exports.strictModeParametersSchema = exports.specialParametersSchemasV4 = exports.specialParametersSchemasV3 = exports.specialParametersSchemasV2 = exports.specialParametersSchemas = exports.outputPathsSchema = void 0;
 const zod_1 = require("zod");
 const EmptySchemaStrategy_enum_1 = require("../../core/types/enums/EmptySchemaStrategy.enum");
+const ModelsMode_enum_1 = require("../../core/types/enums/ModelsMode.enum");
 const ValidationLibrary_enum_1 = require("../../core/types/enums/ValidationLibrary.enum");
 /** Output paths */
 exports.outputPathsSchema = zod_1.z.object({
@@ -37,14 +38,46 @@ exports.specialParametersSchemasV3 = zod_1.z.object({
 exports.specialParametersSchemasV4 = zod_1.z.object({
     ...exports.specialParametersSchemasV3.shape,
     emptySchemaStrategy: zod_1.z.enum(EmptySchemaStrategy_enum_1.EmptySchemaStrategy).optional(),
+    strictOpenapi: zod_1.z.boolean().optional(),
+    reportFile: zod_1.z.string().optional(),
+    governanceConfig: zod_1.z.string().optional(),
+});
+exports.strictModeParametersSchema = zod_1.z.object({
+    strictOpenapi: zod_1.z.boolean().optional(),
+    reportFile: zod_1.z.string().optional(),
 });
 /** Additional parameters */
 exports.additionalParametersSchema = zod_1.z.object({
     clean: zod_1.z.boolean().optional(),
     request: zod_1.z.string().optional(),
+    plugins: zod_1.z.array(zod_1.z.string()).optional(),
     interfacePrefix: zod_1.z.string().optional(),
     enumPrefix: zod_1.z.string().optional(),
     typePrefix: zod_1.z.string().optional(),
+    useHistory: zod_1.z.boolean().optional(),
+    diffReport: zod_1.z.string().optional(),
+    modelsMode: zod_1.z.enum(ModelsMode_enum_1.ModelsMode).optional(),
+});
+exports.modelsConfigSchema = zod_1.z.object({
+    mode: zod_1.z.enum(ModelsMode_enum_1.ModelsMode).optional(),
+    corePath: zod_1.z.string().optional(),
+    modelsPath: zod_1.z.string().optional(),
+});
+exports.analyzeConfigSchema = zod_1.z.object({
+    reportPath: zod_1.z.string().optional(),
+    useHistory: zod_1.z.boolean().optional(),
+    ignore: zod_1.z.array(zod_1.z.object({
+        path: zod_1.z.string().optional(),
+        pattern: zod_1.z.string().optional(),
+        reason: zod_1.z.string().optional(),
+        until: zod_1.z.string().optional(),
+    })).optional(),
+    failOnBreaking: zod_1.z.boolean().optional(),
+});
+exports.miraclesConfigSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().optional(),
+    confidence: zod_1.z.number().min(0).max(1).optional(),
+    types: zod_1.z.array(zod_1.z.enum(['RENAME', 'TYPE_COERCION'])).optional(),
 });
 exports.additionalParametersSchemaV2 = exports.additionalParametersSchema.omit({
     clean: true,

package/dist/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV1.d.ts

@@ -8,9 +8,13 @@ export declare const multiOptionsSchemaV1: z.ZodObject<{
     }, z.core.$strip>>;
     clean: z.ZodOptional<z.ZodBoolean>;
     request: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
+    useHistory: z.ZodOptional<z.ZodBoolean>;
+    diffReport: z.ZodOptional<z.ZodString>;
+    modelsMode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
     exportCore: z.ZodOptional<z.ZodBoolean>;
     exportServices: z.ZodOptional<z.ZodBoolean>;
     exportModels: z.ZodOptional<z.ZodBoolean>;

package/dist/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MultiOptionsSchemaV1.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAO/B,CAAC"}
+{"version":3,"file":"MultiOptionsSchemaV1.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO/B,CAAC"}

package/dist/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV2.d.ts

@@ -15,9 +15,13 @@ export declare const multiOptionsSchemaV2: z.ZodObject<{
     exportSchemas: z.ZodOptional<z.ZodBoolean>;
     clean: z.ZodOptional<z.ZodBoolean>;
     request: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
+    useHistory: z.ZodOptional<z.ZodBoolean>;
+    diffReport: z.ZodOptional<z.ZodString>;
+    modelsMode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
     items: z.ZodArray<z.ZodObject<{
         input: z.ZodString;
     }, z.core.$strip>>;

package/dist/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MultiOptionsSchemaV2.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAE/B,CAAC"}
+{"version":3,"file":"MultiOptionsSchemaV2.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE/B,CAAC"}

package/dist/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV3.d.ts

@@ -18,9 +18,13 @@ export declare const multiOptionsSchemaV3: z.ZodObject<{
     exportSchemas: z.ZodOptional<z.ZodBoolean>;
     clean: z.ZodOptional<z.ZodBoolean>;
     request: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
+    useHistory: z.ZodOptional<z.ZodBoolean>;
+    diffReport: z.ZodOptional<z.ZodString>;
+    modelsMode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
     items: z.ZodArray<z.ZodObject<{
         input: z.ZodString;
     }, z.core.$strip>>;

package/dist/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MultiOptionsSchemaV3.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV3.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAKtB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;iBAG/B,CAAC"}
+{"version":3,"file":"MultiOptionsSchemaV3.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV3.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAKtB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG/B,CAAC"}

package/dist/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV4.d.ts

@@ -13,9 +13,13 @@ export declare const multiOptionsSchemaV4: z.ZodObject<{
     useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
     clean: z.ZodOptional<z.ZodBoolean>;
     request: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
+    useHistory: z.ZodOptional<z.ZodBoolean>;
+    diffReport: z.ZodOptional<z.ZodString>;
+    modelsMode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
     exportCore: z.ZodOptional<z.ZodBoolean>;
     exportServices: z.ZodOptional<z.ZodBoolean>;
     exportModels: z.ZodOptional<z.ZodBoolean>;

package/dist/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MultiOptionsSchemaV4.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV4.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAW3C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAM/B,CAAC"}
+{"version":3,"file":"MultiOptionsSchemaV4.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV4.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAW3C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM/B,CAAC"}

package/dist/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV5.d.ts

@@ -4,9 +4,13 @@ export declare const multiOptionsSchemaV5: z.ZodObject<{
     useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
     useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
     request: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
+    useHistory: z.ZodOptional<z.ZodBoolean>;
+    diffReport: z.ZodOptional<z.ZodString>;
+    modelsMode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
     excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
     includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
     useOptions: z.ZodOptional<z.ZodBoolean>;

package/dist/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV5.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MultiOptionsSchemaV5.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV5.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AActB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;iBAK/B,CAAC"}
+{"version":3,"file":"MultiOptionsSchemaV5.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/MultiOptionsVersioned/MultiOptionsSchemaV5.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AActB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;iBAK/B,CAAC"}

package/dist/common/VersionedSchema/OptionsVersioned/OptionsSchemaV1.d.ts

@@ -5,9 +5,13 @@ export declare const optionsSchemaV1: z.ZodObject<{
     client: z.ZodEnum<typeof HttpClient>;
     clean: z.ZodOptional<z.ZodBoolean>;
     request: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
+    useHistory: z.ZodOptional<z.ZodBoolean>;
+    diffReport: z.ZodOptional<z.ZodString>;
+    modelsMode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
     exportCore: z.ZodOptional<z.ZodBoolean>;
     exportServices: z.ZodOptional<z.ZodBoolean>;
     exportModels: z.ZodOptional<z.ZodBoolean>;

package/dist/common/VersionedSchema/OptionsVersioned/OptionsSchemaV1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OptionsSchemaV1.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/OptionsVersioned/OptionsSchemaV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;iBAM1B,CAAC"}
+{"version":3,"file":"OptionsSchemaV1.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/OptionsVersioned/OptionsSchemaV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;iBAM1B,CAAC"}

package/dist/common/VersionedSchema/OptionsVersioned/OptionsSchemaV2.d.ts

@@ -15,9 +15,13 @@ export declare const optionsSchemaV2: z.ZodObject<{
     exportSchemas: z.ZodOptional<z.ZodBoolean>;
     clean: z.ZodOptional<z.ZodBoolean>;
     request: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
+    useHistory: z.ZodOptional<z.ZodBoolean>;
+    diffReport: z.ZodOptional<z.ZodString>;
+    modelsMode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
     httpClient: z.ZodEnum<typeof HttpClient>;
 }, z.core.$strip>;
 //# sourceMappingURL=OptionsSchemaV2.d.ts.map

package/dist/common/VersionedSchema/OptionsVersioned/OptionsSchemaV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OptionsSchemaV2.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/OptionsVersioned/OptionsSchemaV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;iBAE1B,CAAC"}
+{"version":3,"file":"OptionsSchemaV2.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/OptionsVersioned/OptionsSchemaV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;iBAE1B,CAAC"}

package/dist/common/VersionedSchema/OptionsVersioned/OptionsSchemaV3.d.ts

@@ -18,9 +18,13 @@ export declare const optionsSchemaV3: z.ZodObject<{
     exportSchemas: z.ZodOptional<z.ZodBoolean>;
     clean: z.ZodOptional<z.ZodBoolean>;
     request: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
+    useHistory: z.ZodOptional<z.ZodBoolean>;
+    diffReport: z.ZodOptional<z.ZodString>;
+    modelsMode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
     httpClient: z.ZodEnum<typeof import("../../..").HttpClient>;
 }, z.core.$strip>;
 //# sourceMappingURL=OptionsSchemaV3.d.ts.map

package/dist/common/VersionedSchema/OptionsVersioned/OptionsSchemaV3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OptionsSchemaV3.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/OptionsVersioned/OptionsSchemaV3.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;iBAG1B,CAAC"}
+{"version":3,"file":"OptionsSchemaV3.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/OptionsVersioned/OptionsSchemaV3.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;iBAG1B,CAAC"}

package/dist/common/VersionedSchema/OptionsVersioned/OptionsSchemaV4.d.ts

@@ -7,9 +7,13 @@ export declare const optionsSchemaV4: z.ZodObject<{
     useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
     useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
     request: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
+    useHistory: z.ZodOptional<z.ZodBoolean>;
+    diffReport: z.ZodOptional<z.ZodString>;
+    modelsMode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
     excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
     includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
     useOptions: z.ZodOptional<z.ZodBoolean>;

package/dist/common/VersionedSchema/OptionsVersioned/OptionsSchemaV4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OptionsSchemaV4.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/OptionsVersioned/OptionsSchemaV4.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;iBAO1B,CAAC"}
+{"version":3,"file":"OptionsSchemaV4.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/OptionsVersioned/OptionsSchemaV4.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;iBAO1B,CAAC"}

package/dist/common/VersionedSchema/Utils/__mocks__/compatibilityCases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compatibilityCases.d.ts","sourceRoot":"","sources":["../../../../../src/common/VersionedSchema/Utils/__mocks__/compatibilityCases.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,KAAK,iBAAiB,GAAG;IACrB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,kBAAkB,EAAE,CAAC;CAChC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,EA8FjD,CAAC"}
+{"version":3,"file":"compatibilityCases.d.ts","sourceRoot":"","sources":["../../../../../src/common/VersionedSchema/Utils/__mocks__/compatibilityCases.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,KAAK,iBAAiB,GAAG;IACrB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,kBAAkB,EAAE,CAAC;CAChC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,EAkHjD,CAAC"}

package/dist/common/VersionedSchema/Utils/__mocks__/compatibilityCases.js

@@ -93,12 +93,32 @@ exports.compatibilityCases = [
         type: Enums_1.EVersionedSchemaType.UNIFIED_OPTIONS,
         from: 'v2',
         to: 'v3',
-        expect: [{ type: 'added', key: 'logLevel' }, { type: 'added', key: 'logTarget' }],
+        expect: [
+            { type: 'added', key: 'logLevel' },
+            { type: 'added', key: 'logTarget' },
+        ],
     },
     {
         type: Enums_1.EVersionedSchemaType.UNIFIED_OPTIONS,
         from: 'v3',
         to: 'v4',
-        expect: [{ type: 'added', key: 'emptySchemaStrategy' }, { type: 'added', key: 'customExecutorPath' }]
-    }
+        expect: [
+            { type: 'added', key: 'emptySchemaStrategy' },
+            { type: 'added', key: 'strictOpenapi' },
+            { type: 'added', key: 'reportFile' },
+            { type: 'added', key: 'governanceConfig' },
+            { type: 'added', key: 'customExecutorPath' },
+            { type: 'added', key: 'models' },
+            { type: 'added', key: 'analyze' },
+            { type: 'added', key: 'miracles' },
+        ],
+    },
+    {
+        type: Enums_1.EVersionedSchemaType.UNIFIED_OPTIONS,
+        from: 'v4',
+        to: 'v5',
+        expect: [
+            { type: 'added', key: 'useProjectPrettier' }, { type: 'added', key: 'useEslintFix' },
+        ],
+    },
 ];

package/dist/common/VersionedSchema/Utils/__tests__/migrateDataToLatestSchemaVersion.test.js

@@ -69,7 +69,7 @@ const migrateDataToLatestSchemaVersion_1 = require("../migrateDataToLatestSchema
     });
     node_assert_1.default.ok(result);
     node_assert_1.default.strictEqual(result?.schemaType, Enums_2.EVersionedSchemaType.UNIFIED_OPTIONS);
-    node_assert_1.default.strictEqual(result?.schemaVersion, 'UNIFIED_OPTIONS_v4');
+    node_assert_1.default.strictEqual(result?.schemaVersion, 'UNIFIED_OPTIONS_v5');
     node_assert_1.default.strictEqual(result?.value.httpClient, 'fetch');
     node_assert_1.default.strictEqual(result?.value.validationLibrary, ValidationLibrary_enum_1.ValidationLibrary.NONE);
 });
@@ -88,6 +88,6 @@ const migrateDataToLatestSchemaVersion_1 = require("../migrateDataToLatestSchema
     });
     node_assert_1.default.ok(result);
     node_assert_1.default.strictEqual(result?.schemaType, Enums_2.EVersionedSchemaType.UNIFIED_OPTIONS);
-    node_assert_1.default.strictEqual(result?.schemaVersion, 'UNIFIED_OPTIONS_v4');
+    node_assert_1.default.strictEqual(result?.schemaVersion, 'UNIFIED_OPTIONS_v5');
     node_assert_1.default.ok(result?.guessedVersion.latestVersion.startsWith('OPTIONS_'));
 });

package/dist/common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migrateDataToLatestSchemaVersion.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AASpF;;GAEG;AACH,KAAK,oBAAoB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,cAAc,EAAE,mBAAmB,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;IAChF,gBAAgB,EAAE,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC;IAClD,aAAa,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,KAAK,qBAAqB,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,cAAc,EAAE,kBAAkB,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,oBAAoB,CAAC;CACpC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gCAAgC,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAE,EAAE,oBAAoB,GAAG,qBAAqB,GAAG,IAAI,CAoFlK"}
+{"version":3,"file":"migrateDataToLatestSchemaVersion.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AASpF;;GAEG;AACH,KAAK,oBAAoB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,cAAc,EAAE,mBAAmB,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;IAChF,gBAAgB,EAAE,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC;IAClD,aAAa,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,KAAK,qBAAqB,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,cAAc,EAAE,kBAAkB,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,oBAAoB,CAAC;CACpC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gCAAgC,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAE,EAAE,oBAAoB,GAAG,qBAAqB,GAAG,IAAI,CAkFlK"}

package/dist/common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.migrateDataToLatestSchemaVersion = migrateDataToLatestSchemaVersion;
 const Consts_1 = require("../../Consts");
+const LoggerMessages_1 = require("../../LoggerMessages");
 const Enums_1 = require("../../Enums");
 const validateZodOptions_1 = require("../../Validation/validateZodOptions");
 const determineBestMatchingSchemaVersion_1 = require("./determineBestMatchingSchemaVersion");
@@ -65,7 +66,7 @@ function migrateDataToLatestSchemaVersion({ rawInput, migrationPlans, versionedS
         }
         visitedVersions.add(currentVersion);
         if (currentVersion === actualSchema.version && migrationMode === Enums_1.EMigrationMode.GENERATE_OPENAPI) {
-            Consts_1.APP_LOGGER.warn('To perform OpenAPI generation, it was necessary to migrate the schema of your data to the current one. To update the configuration in the file, use the command `npm openapi-codegen-cli update-config`');
+            Consts_1.APP_LOGGER.warn(LoggerMessages_1.LOGGER_MESSAGES.MIGRATION.OPENAPI_SCHEMA_MIGRATED);
         }
     }
     const validationResult = (0, validateZodOptions_1.validateZodOptionsRaw)(actualSchema.schema, currentData);

package/dist/common/__tests__/Logger.test.d.ts

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

package/dist/common/__tests__/Logger.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.test.d.ts","sourceRoot":"","sources":["../../../src/common/__tests__/Logger.test.ts"],"names":[],"mappings":""}

package/dist/common/__tests__/Logger.test.js

@@ -0,0 +1,100 @@
+"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 Enums_1 = require("../Enums");
+const Logger_1 = require("../Logger");
+const LoggerMessages_1 = require("../LoggerMessages");
+(0, node_test_1.describe)('@unit: Logger', () => {
+    (0, node_test_1.test)('errorWithHint should log error with recommendation for known code', () => {
+        const logger = new Logger_1.Logger({
+            instanceId: 'test',
+            level: Enums_1.ELogLevel.ERROR,
+            logOutput: Enums_1.ELogOutput.CONSOLE,
+            disableColors: true,
+        });
+        const loggerErrorMock = node_test_1.mock.fn();
+        const loggerInfoMock = node_test_1.mock.fn();
+        const loggerWarnMock = node_test_1.mock.fn();
+        logger._logger = {
+            error: loggerErrorMock,
+            info: loggerInfoMock,
+            warn: loggerWarnMock,
+            level: 'error',
+            log: node_test_1.mock.fn(),
+        };
+        const code = LoggerMessages_1.LOGGER_ERROR_CODES.CONFIG_FILE_MISSING;
+        const recommendation = LoggerMessages_1.LOGGER_ERROR_RECOMMENDATIONS[code];
+        const exitMock = node_test_1.mock.method(process, 'exit', () => {
+            // nothing
+        });
+        logger.errorWithHint({ code });
+        node_assert_1.default.strictEqual(loggerErrorMock.mock.callCount(), 1);
+        node_assert_1.default.ok(String(loggerErrorMock.mock.calls[0].arguments[0]).includes('Error:'), 'error message should contain "Error:" prefix');
+        node_assert_1.default.ok(loggerInfoMock.mock.callCount() >= 2);
+        const infoMessages = loggerInfoMock.mock.calls.map(call => String(call.arguments[0]));
+        node_assert_1.default.ok(infoMessages.some(msg => msg.includes('What you can do next')), 'info should contain recommendation title');
+        node_assert_1.default.ok(infoMessages.some(msg => msg.includes(recommendation)), 'info should contain concrete recommendation text');
+        // Logger no longer calls process.exit; caller is responsible for flush and exit
+        node_assert_1.default.strictEqual(exitMock.mock.callCount(), 0);
+    });
+    (0, node_test_1.test)('success should delegate to internal logger with success level', () => {
+        const logger = new Logger_1.Logger({
+            instanceId: 'test',
+            level: Enums_1.ELogLevel.INFO,
+            logOutput: Enums_1.ELogOutput.CONSOLE,
+            disableColors: true,
+        });
+        const logMock = node_test_1.mock.fn();
+        logger._logger = {
+            log: logMock,
+            level: 'info',
+        };
+        logger.success('Done');
+        node_assert_1.default.strictEqual(logMock.mock.callCount(), 1);
+        const [level, message] = logMock.mock.calls[0].arguments;
+        node_assert_1.default.strictEqual(level, 'success');
+        node_assert_1.default.strictEqual(message, 'Done');
+    });
+    (0, node_test_1.test)('error should not call process.exit', () => {
+        const logger = new Logger_1.Logger({
+            instanceId: 'test',
+            level: Enums_1.ELogLevel.ERROR,
+            logOutput: Enums_1.ELogOutput.CONSOLE,
+            disableColors: true,
+        });
+        const loggerErrorMock = node_test_1.mock.fn();
+        logger._logger = { error: loggerErrorMock, level: 'error' };
+        const exitMock = node_test_1.mock.method(process, 'exit', () => {
+            throw new Error('process.exit should not be called by Logger.error');
+        });
+        logger.error('Something failed');
+        node_assert_1.default.strictEqual(loggerErrorMock.mock.callCount(), 1);
+        node_assert_1.default.strictEqual(exitMock.mock.callCount(), 0);
+    });
+    (0, node_test_1.test)('shutdownLoggerAsync should resolve and close transports', async () => {
+        const logger = new Logger_1.Logger({
+            instanceId: 'test',
+            level: Enums_1.ELogLevel.INFO,
+            logOutput: Enums_1.ELogOutput.CONSOLE,
+            disableColors: true,
+        });
+        let closeCalled = false;
+        const mockTransport = {
+            close(cb) {
+                closeCalled = true;
+                if (typeof cb === 'function')
+                    cb();
+            },
+        };
+        logger._logger = {
+            transports: [mockTransport],
+            close: node_test_1.mock.fn(),
+        };
+        await logger.shutdownLoggerAsync();
+        node_assert_1.default.strictEqual(closeCalled, true);
+    });
+});

package/dist/common/utils/__tests__/convertArrayToObject.test.js

@@ -70,6 +70,9 @@ const convertArrayToObject_1 = require("../convertArrayToObject");
             useSeparatedIndexes: undefined,
             validationLibrary: undefined,
             emptySchemaStrategy: undefined,
+            modelsMode: undefined,
+            useHistory: undefined,
+            diffReport: undefined,
             request: undefined,
             customExecutorPath: undefined,
             items: [

package/dist/common/utils/__tests__/eslintFix.test.d.ts

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

package/dist/common/utils/__tests__/eslintFix.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eslintFix.test.d.ts","sourceRoot":"","sources":["../../../../src/common/utils/__tests__/eslintFix.test.ts"],"names":[],"mappings":""}

package/dist/common/utils/__tests__/eslintFix.test.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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_path_1 = __importDefault(require("node:path"));
+const node_test_1 = require("node:test");
+const Consts_1 = require("../../Consts");
+(0, node_test_1.describe)('@unit: eslintFix', () => {
+    let warnMessages = [];
+    let infoMessages = [];
+    let errorWithHintCalls = [];
+    const originalWarn = Consts_1.APP_LOGGER.warn.bind(Consts_1.APP_LOGGER);
+    const originalInfo = Consts_1.APP_LOGGER.info.bind(Consts_1.APP_LOGGER);
+    const originalErrorWithHint = Consts_1.APP_LOGGER.errorWithHint.bind(Consts_1.APP_LOGGER);
+    (0, node_test_1.beforeEach)(() => {
+        warnMessages = [];
+        infoMessages = [];
+        errorWithHintCalls = [];
+        Consts_1.APP_LOGGER.warn = (msg) => {
+            warnMessages.push(msg);
+        };
+        Consts_1.APP_LOGGER.info = (msg) => {
+            infoMessages.push(msg);
+        };
+        Consts_1.APP_LOGGER.errorWithHint = options => {
+            errorWithHintCalls.push({
+                code: options.code,
+                message: options.message,
+                error: options.error,
+            });
+        };
+    });
+    (0, node_test_1.afterEach)(() => {
+        Consts_1.APP_LOGGER.warn = originalWarn;
+        Consts_1.APP_LOGGER.info = originalInfo;
+        Consts_1.APP_LOGGER.errorWithHint = originalErrorWithHint;
+    });
+    (0, node_test_1.describe)('when eslint is available', () => {
+        (0, node_test_1.test)('calls lintFiles and outputFixes and logs ESLINT_FIX_APPLIED', async () => {
+            // We import eslintFix here after mocking APP_LOGGER.
+            // If ESLint is installed in the project, it will run; otherwise the warn path is tested.
+            const { eslintFix } = await Promise.resolve().then(() => __importStar(require('../eslintFix')));
+            const filePath = node_path_1.default.resolve(__dirname, '__fixtures__/dummy.ts');
+            let threw = false;
+            try {
+                await eslintFix(filePath);
+            }
+            catch {
+                threw = true;
+            }
+            if (!threw) {
+                // ESLint is available — it either applied fixes or logged info
+                const fixApplied = infoMessages.some(m => m.includes('ESLint fix applied') || m.includes(filePath));
+                const notInstalled = warnMessages.some(m => m.includes('ESLint is not installed'));
+                node_assert_1.default.ok(fixApplied || notInstalled, 'should log either fix applied or not installed');
+            }
+        });
+    });
+    (0, node_test_1.describe)('when eslint is NOT available (graceful fallback)', () => {
+        (0, node_test_1.test)('logs ESLINT_NOT_INSTALLED warning and does not throw', async () => {
+            // Patch the module by temporarily replacing the tryImportESLint logic
+            // via an environment variable guard checked in eslintFix
+            // Since we can't easily mock dynamic import in tsx, we test the exported function
+            // with a patched internal approach: we verify the module itself handles the error.
+            // Re-import to get a fresh reference; the real behavior depends on whether eslint is installed.
+            const { eslintFix } = await Promise.resolve().then(() => __importStar(require('../eslintFix')));
+            // If eslint is not installed in devDeps, calling eslintFix should warn and not throw.
+            // If it IS installed, this test is a no-op (covered by the other test).
+            try {
+                await eslintFix('/non/existent/path/that/wont/lint.ts');
+                // Either it runs eslint on the fake path (may fail) or warns about not installed
+            }
+            catch {
+                // If eslint is installed but fails on non-existent path, verify errorWithHint was called
+                node_assert_1.default.ok(errorWithHintCalls.some(c => c.code === 'ESLINT_FIX_FAILED'), 'should call errorWithHint with ESLINT_FIX_FAILED when eslint throws');
+            }
+        });
+    });
+    (0, node_test_1.describe)('when eslint throws during fix', () => {
+        (0, node_test_1.test)('calls APP_LOGGER.errorWithHint with ESLINT_FIX_FAILED and re-throws', async () => {
+            const { eslintFix } = await Promise.resolve().then(() => __importStar(require('../eslintFix')));
+            // Pass a path that will cause ESLint to fail if installed
+            let threw = false;
+            try {
+                await eslintFix('/path/does/not/exist/file.ts');
+            }
+            catch {
+                threw = true;
+            }
+            if (threw) {
+                node_assert_1.default.ok(errorWithHintCalls.some(c => c.code === 'ESLINT_FIX_FAILED'), 'should log ESLINT_FIX_FAILED before re-throwing');
+            }
+            else {
+                // ESLint not installed — check warn was logged
+                node_assert_1.default.ok(warnMessages.some(m => m.includes('ESLint is not installed')), 'should warn that ESLint is not installed');
+            }
+        });
+    });
+});

package/dist/common/utils/__tests__/format.test.d.ts

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

package/dist/common/utils/__tests__/format.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.test.d.ts","sourceRoot":"","sources":["../../../../src/common/utils/__tests__/format.test.ts"],"names":[],"mappings":""}