ts-openapi-codegen 2.0.0-beta.9 → 2.0.0

package/dist/common/VersionedSchema/AllVersionedSchemas/UnifiedVersionedSchemas.d.ts

@@ -1,44 +1,168 @@
 import { z } from 'zod';
 import { VersionedSchema } from '../Types';
-export declare const unifiedVersionedSchemas: VersionedSchema<z.ZodTypeAny>[];
-export declare const rawOptionsSchema: z.ZodObject<{
-    logLevel: z.ZodOptional<z.ZodEnum<typeof import("../../Enums").ELogLevel>>;
-    logTarget: z.ZodOptional<z.ZodEnum<typeof import("../../Enums").ELogOutput>>;
-    useOptions: z.ZodOptional<z.ZodBoolean>;
-    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
-    excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
-    validationLibrary: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ValidationLibrary.enum").ValidationLibrary>>;
-    sortByRequired: z.ZodOptional<z.ZodBoolean>;
-    useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
-    useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
-    request: z.ZodOptional<z.ZodString>;
-    interfacePrefix: z.ZodOptional<z.ZodString>;
-    enumPrefix: z.ZodOptional<z.ZodString>;
-    typePrefix: z.ZodOptional<z.ZodString>;
-    includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
-    outputCore: z.ZodOptional<z.ZodString>;
-    outputServices: z.ZodOptional<z.ZodString>;
-    outputModels: z.ZodOptional<z.ZodString>;
-    outputSchemas: z.ZodOptional<z.ZodString>;
-    items: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        input: z.ZodString;
+type Last<T extends readonly unknown[]> = T extends readonly [...infer _, infer L] ? L : never;
+declare const unifiedSchemaDefinitions: readonly [{
+    readonly version: "v1";
+    readonly base: z.ZodObject<{
+        sortByRequired: z.ZodOptional<z.ZodBoolean>;
+        useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
+        useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
         request: z.ZodOptional<z.ZodString>;
+        interfacePrefix: z.ZodOptional<z.ZodString>;
+        enumPrefix: z.ZodOptional<z.ZodString>;
+        typePrefix: z.ZodOptional<z.ZodString>;
+        excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
+        includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
+        useOptions: z.ZodOptional<z.ZodBoolean>;
+        useUnionTypes: z.ZodOptional<z.ZodBoolean>;
+        outputCore: z.ZodOptional<z.ZodString>;
+        outputServices: z.ZodOptional<z.ZodString>;
+        outputModels: z.ZodOptional<z.ZodString>;
+        outputSchemas: z.ZodOptional<z.ZodString>;
+        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            input: z.ZodString;
+            request: z.ZodOptional<z.ZodString>;
+            sortByRequired: z.ZodOptional<z.ZodBoolean>;
+            useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
+            useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+            interfacePrefix: z.ZodOptional<z.ZodString>;
+            enumPrefix: z.ZodOptional<z.ZodString>;
+            typePrefix: z.ZodOptional<z.ZodString>;
+            output: z.ZodString;
+            outputCore: z.ZodOptional<z.ZodString>;
+            outputServices: z.ZodOptional<z.ZodString>;
+            outputModels: z.ZodOptional<z.ZodString>;
+            outputSchemas: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        input: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodString>;
+        httpClient: z.ZodEnum<typeof import("../../..").HttpClient>;
+    }, z.core.$strip>;
+}, {
+    readonly version: "v2";
+    readonly base: z.ZodObject<{
+        excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
+        validationLibrary: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ValidationLibrary.enum").ValidationLibrary>>;
+        useOptions: z.ZodOptional<z.ZodBoolean>;
+        useUnionTypes: z.ZodOptional<z.ZodBoolean>;
         sortByRequired: z.ZodOptional<z.ZodBoolean>;
         useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
         useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+        request: z.ZodOptional<z.ZodString>;
         interfacePrefix: z.ZodOptional<z.ZodString>;
         enumPrefix: z.ZodOptional<z.ZodString>;
         typePrefix: z.ZodOptional<z.ZodString>;
-        output: z.ZodString;
+        includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
         outputCore: z.ZodOptional<z.ZodString>;
         outputServices: z.ZodOptional<z.ZodString>;
         outputModels: z.ZodOptional<z.ZodString>;
         outputSchemas: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    input: z.ZodOptional<z.ZodString>;
-    output: z.ZodOptional<z.ZodString>;
-    httpClient: z.ZodEnum<typeof import("../../..").HttpClient>;
-}, z.core.$strip>;
+        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            input: z.ZodString;
+            request: z.ZodOptional<z.ZodString>;
+            sortByRequired: z.ZodOptional<z.ZodBoolean>;
+            useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
+            useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+            interfacePrefix: z.ZodOptional<z.ZodString>;
+            enumPrefix: z.ZodOptional<z.ZodString>;
+            typePrefix: z.ZodOptional<z.ZodString>;
+            output: z.ZodString;
+            outputCore: z.ZodOptional<z.ZodString>;
+            outputServices: z.ZodOptional<z.ZodString>;
+            outputModels: z.ZodOptional<z.ZodString>;
+            outputSchemas: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        input: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodString>;
+        httpClient: z.ZodEnum<typeof import("../../..").HttpClient>;
+    }, z.core.$strip>;
+}, {
+    readonly version: "v3";
+    readonly base: z.ZodObject<{
+        logLevel: z.ZodOptional<z.ZodEnum<typeof import("../../Enums").ELogLevel>>;
+        logTarget: z.ZodOptional<z.ZodEnum<typeof import("../../Enums").ELogOutput>>;
+        excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
+        validationLibrary: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ValidationLibrary.enum").ValidationLibrary>>;
+        useOptions: z.ZodOptional<z.ZodBoolean>;
+        useUnionTypes: z.ZodOptional<z.ZodBoolean>;
+        sortByRequired: z.ZodOptional<z.ZodBoolean>;
+        useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
+        useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+        request: z.ZodOptional<z.ZodString>;
+        interfacePrefix: z.ZodOptional<z.ZodString>;
+        enumPrefix: z.ZodOptional<z.ZodString>;
+        typePrefix: z.ZodOptional<z.ZodString>;
+        includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
+        outputCore: z.ZodOptional<z.ZodString>;
+        outputServices: z.ZodOptional<z.ZodString>;
+        outputModels: z.ZodOptional<z.ZodString>;
+        outputSchemas: z.ZodOptional<z.ZodString>;
+        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            input: z.ZodString;
+            request: z.ZodOptional<z.ZodString>;
+            sortByRequired: z.ZodOptional<z.ZodBoolean>;
+            useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
+            useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+            interfacePrefix: z.ZodOptional<z.ZodString>;
+            enumPrefix: z.ZodOptional<z.ZodString>;
+            typePrefix: z.ZodOptional<z.ZodString>;
+            output: z.ZodString;
+            outputCore: z.ZodOptional<z.ZodString>;
+            outputServices: z.ZodOptional<z.ZodString>;
+            outputModels: z.ZodOptional<z.ZodString>;
+            outputSchemas: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        input: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodString>;
+        httpClient: z.ZodEnum<typeof import("../../..").HttpClient>;
+    }, z.core.$strip>;
+}, {
+    readonly version: "v4";
+    readonly base: z.ZodObject<{
+        logLevel: z.ZodOptional<z.ZodEnum<typeof import("../../Enums").ELogLevel>>;
+        logTarget: z.ZodOptional<z.ZodEnum<typeof import("../../Enums").ELogOutput>>;
+        sortByRequired: z.ZodOptional<z.ZodBoolean>;
+        useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
+        useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+        request: z.ZodOptional<z.ZodString>;
+        interfacePrefix: z.ZodOptional<z.ZodString>;
+        enumPrefix: z.ZodOptional<z.ZodString>;
+        typePrefix: z.ZodOptional<z.ZodString>;
+        includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
+        outputCore: z.ZodOptional<z.ZodString>;
+        outputServices: z.ZodOptional<z.ZodString>;
+        outputModels: z.ZodOptional<z.ZodString>;
+        outputSchemas: z.ZodOptional<z.ZodString>;
+        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            input: z.ZodString;
+            request: z.ZodOptional<z.ZodString>;
+            sortByRequired: z.ZodOptional<z.ZodBoolean>;
+            useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
+            useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+            interfacePrefix: z.ZodOptional<z.ZodString>;
+            enumPrefix: z.ZodOptional<z.ZodString>;
+            typePrefix: z.ZodOptional<z.ZodString>;
+            output: z.ZodString;
+            outputCore: z.ZodOptional<z.ZodString>;
+            outputServices: z.ZodOptional<z.ZodString>;
+            outputModels: z.ZodOptional<z.ZodString>;
+            outputSchemas: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        input: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodString>;
+        httpClient: z.ZodEnum<typeof import("../../..").HttpClient>;
+        customExecutorPath: z.ZodOptional<z.ZodString>;
+        emptySchemaStrategy: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/EmptySchemaStrategy.enum").EmptySchemaStrategy>>;
+        excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
+        validationLibrary: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ValidationLibrary.enum").ValidationLibrary>>;
+        useOptions: z.ZodOptional<z.ZodBoolean>;
+        useUnionTypes: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}];
+type UnifiedSchemaDefinitions = typeof unifiedSchemaDefinitions;
+type LatestUnifiedDefinition = Last<UnifiedSchemaDefinitions>;
+export declare const unifiedVersionedSchemas: VersionedSchema<z.ZodTypeAny>[];
+export declare const rawOptionsSchema: LatestUnifiedDefinition['base'];
 export declare const flatOptionsSchema: z.ZodObject<{
     outputCore: z.ZodOptional<z.ZodString>;
     outputServices: z.ZodOptional<z.ZodString>;
@@ -49,6 +173,7 @@ export declare const flatOptionsSchema: z.ZodObject<{
     excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
     includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
     validationLibrary: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ValidationLibrary.enum").ValidationLibrary>>;
+    emptySchemaStrategy: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/EmptySchemaStrategy.enum").EmptySchemaStrategy>>;
     request: z.ZodOptional<z.ZodString>;
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
@@ -59,7 +184,9 @@ export declare const flatOptionsSchema: z.ZodObject<{
     httpClient: z.ZodEnum<typeof import("../../..").HttpClient>;
     logLevel: z.ZodOptional<z.ZodEnum<typeof import("../../Enums").ELogLevel>>;
     logTarget: z.ZodOptional<z.ZodEnum<typeof import("../../Enums").ELogOutput>>;
+    customExecutorPath: z.ZodOptional<z.ZodString>;
     input: z.ZodString;
     output: z.ZodString;
 }, z.core.$strip>;
+export {};
 //# sourceMappingURL=UnifiedVersionedSchemas.d.ts.map

package/dist/common/VersionedSchema/AllVersionedSchemas/UnifiedVersionedSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UnifiedVersionedSchemas.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/AllVersionedSchemas/UnifiedVersionedSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAM3C,eAAO,MAAM,uBAAuB,EAAE,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,EAgBlE,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyB,CAAC;AAEvD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;iBAG5B,CAAC"}
+{"version":3,"file":"UnifiedVersionedSchemas.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/AllVersionedSchemas/UnifiedVersionedSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAQ3C,KAAK,IAAI,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,SAAS,CAAC,GAAG,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE/F,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKpB,CAAC;AAEX,KAAK,wBAAwB,GAAG,OAAO,wBAAwB,CAAC;AAChE,KAAK,uBAAuB,GAAG,IAAI,CAAC,wBAAwB,CAAC,CAAC;AAE9D,eAAO,MAAM,uBAAuB,EAAE,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,EAMlE,CAAC;AAIF,eAAO,MAAM,gBAAgB,EAAE,uBAAuB,CAAC,MAAM,CAAgC,CAAC;AAE9F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;iBAG5B,CAAC"}

package/dist/common/VersionedSchema/AllVersionedSchemas/UnifiedVersionedSchemas.js

@@ -7,24 +7,20 @@ const buildVersionedSchema_1 = require("../Utils/buildVersionedSchema");
 const UnifiedOptionsSchemaV1_1 = require("./UnifiedOptionsSchemaV1");
 const UnifiedOptionsSchemaV2_1 = require("./UnifiedOptionsSchemaV2");
 const UnifiedOptionsSchemaV3_1 = require("./UnifiedOptionsSchemaV3");
-exports.unifiedVersionedSchemas = [
-    (0, buildVersionedSchema_1.buildVersionedSchema)({
-        version: 'v1',
-        base: UnifiedOptionsSchemaV1_1.unifiedOptionsSchemaV1,
-        type: Enums_1.EVersionedSchemaType.UNIFIED_OPTIONS,
-    }),
-    (0, buildVersionedSchema_1.buildVersionedSchema)({
-        version: 'v2',
-        base: UnifiedOptionsSchemaV2_1.unifiedOptionsSchemaV2,
-        type: Enums_1.EVersionedSchemaType.UNIFIED_OPTIONS,
-    }),
-    (0, buildVersionedSchema_1.buildVersionedSchema)({
-        version: 'v3',
-        base: UnifiedOptionsSchemaV3_1.unifiedOptionsSchemaV3,
-        type: Enums_1.EVersionedSchemaType.UNIFIED_OPTIONS,
-    }),
+const UnifiedOptionsSchemaV4_1 = require("./UnifiedOptionsSchemaV4");
+const unifiedSchemaDefinitions = [
+    { version: 'v1', base: UnifiedOptionsSchemaV1_1.unifiedOptionsSchemaV1 },
+    { version: 'v2', base: UnifiedOptionsSchemaV2_1.unifiedOptionsSchemaV2 },
+    { version: 'v3', base: UnifiedOptionsSchemaV3_1.unifiedOptionsSchemaV3 },
+    { version: 'v4', base: UnifiedOptionsSchemaV4_1.unifiedOptionsSchemaV4 },
 ];
-exports.rawOptionsSchema = UnifiedOptionsSchemaV3_1.unifiedOptionsSchemaV3;
+exports.unifiedVersionedSchemas = unifiedSchemaDefinitions.map(({ version, base }) => (0, buildVersionedSchema_1.buildVersionedSchema)({
+    version,
+    base,
+    type: Enums_1.EVersionedSchemaType.UNIFIED_OPTIONS,
+}));
+const latestUnifiedDefinition = unifiedSchemaDefinitions[unifiedSchemaDefinitions.length - 1];
+exports.rawOptionsSchema = latestUnifiedDefinition.base;
 exports.flatOptionsSchema = exports.rawOptionsSchema.omit({ items: true }).extend({
     input: zod_1.z.string().min(1, 'Input is required'),
     output: zod_1.z.string().min(1, 'Output is required'),

package/dist/common/VersionedSchema/CommonSchemas.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { EmptySchemaStrategy } from '../../core/types/enums/EmptySchemaStrategy.enum';
 import { ValidationLibrary } from '../../core/types/enums/ValidationLibrary.enum';
 /** Output paths */
 export declare const outputPathsSchema: z.ZodObject<{
@@ -9,24 +10,31 @@ export declare const outputPathsSchema: z.ZodObject<{
     outputSchemas: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const specialParametersSchemas: z.ZodObject<{
-    useOptions: z.ZodOptional<z.ZodBoolean>;
-    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
     exportCore: z.ZodOptional<z.ZodBoolean>;
     exportServices: z.ZodOptional<z.ZodBoolean>;
     exportModels: z.ZodOptional<z.ZodBoolean>;
     exportSchemas: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const specialParametersSchemasV2: z.ZodObject<{
     useOptions: z.ZodOptional<z.ZodBoolean>;
     useUnionTypes: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const specialParametersSchemasV2: z.ZodObject<{
     excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
     includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
+    useOptions: z.ZodOptional<z.ZodBoolean>;
+    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const specialParametersSchemasV3: z.ZodObject<{
+    excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
+    validationLibrary: z.ZodOptional<z.ZodEnum<typeof ValidationLibrary>>;
     useOptions: z.ZodOptional<z.ZodBoolean>;
     useUnionTypes: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const specialParametersSchemasV4: z.ZodObject<{
+    emptySchemaStrategy: z.ZodOptional<z.ZodEnum<typeof EmptySchemaStrategy>>;
     excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
     validationLibrary: z.ZodOptional<z.ZodEnum<typeof ValidationLibrary>>;
+    useOptions: z.ZodOptional<z.ZodBoolean>;
+    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 /** Additional parameters */
 export declare const additionalParametersSchema: z.ZodObject<{

package/dist/common/VersionedSchema/CommonSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CommonSchemas.d.ts","sourceRoot":"","sources":["../../../src/common/VersionedSchema/CommonSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAElF,mBAAmB;AAEnB,eAAO,MAAM,iBAAiB;;;;;;iBAM5B,CAAC;AASH,eAAO,MAAM,wBAAwB;;;;;;;iBAOpC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;iBAKtC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;iBAKtC,CAAC;AAEF,4BAA4B;AAE5B,eAAO,MAAM,0BAA0B;;;;;;iBAMrC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;iBAEvC,CAAC;AAEH,8BAA8B;AAE9B,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;iBAIzC,CAAC"}
+{"version":3,"file":"CommonSchemas.d.ts","sourceRoot":"","sources":["../../../src/common/VersionedSchema/CommonSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAElF,mBAAmB;AAEnB,eAAO,MAAM,iBAAiB;;;;;;iBAM5B,CAAC;AASH,eAAO,MAAM,wBAAwB;;;;;;;iBAMnC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;iBAIrC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;iBAIrC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;iBAGrC,CAAC;AAEH,4BAA4B;AAE5B,eAAO,MAAM,0BAA0B;;;;;;iBAMrC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;iBAEvC,CAAC;AAEH,8BAA8B;AAE9B,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;iBAIzC,CAAC"}

package/dist/common/VersionedSchema/CommonSchemas.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.experimentalParametersSchemaV2 = exports.experimentalParametersSchema = exports.additionalParametersSchemaV2 = exports.additionalParametersSchema = exports.specialParametersSchemasV3 = exports.specialParametersSchemasV2 = exports.specialParametersSchemas = exports.outputPathsSchema = void 0;
+exports.experimentalParametersSchemaV2 = exports.experimentalParametersSchema = exports.additionalParametersSchemaV2 = exports.additionalParametersSchema = 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 ValidationLibrary_enum_1 = require("../../core/types/enums/ValidationLibrary.enum");
 /** Output paths */
 exports.outputPathsSchema = zod_1.z.object({
@@ -16,20 +17,27 @@ const baseSpecialParametersSchema = zod_1.z.object({
     useOptions: zod_1.z.boolean().optional(),
     useUnionTypes: zod_1.z.boolean().optional(),
 });
-exports.specialParametersSchemas = baseSpecialParametersSchema.merge(zod_1.z.object({
+exports.specialParametersSchemas = zod_1.z.object({
+    ...baseSpecialParametersSchema.shape,
     exportCore: zod_1.z.boolean().optional(),
     exportServices: zod_1.z.boolean().optional(),
     exportModels: zod_1.z.boolean().optional(),
     exportSchemas: zod_1.z.boolean().optional(),
-}));
-exports.specialParametersSchemasV2 = baseSpecialParametersSchema.merge(zod_1.z.object({
+});
+exports.specialParametersSchemasV2 = zod_1.z.object({
+    ...baseSpecialParametersSchema.shape,
     excludeCoreServiceFiles: zod_1.z.boolean().optional(),
     includeSchemasFiles: zod_1.z.boolean().optional(),
-}));
-exports.specialParametersSchemasV3 = baseSpecialParametersSchema.merge(zod_1.z.object({
+});
+exports.specialParametersSchemasV3 = zod_1.z.object({
+    ...baseSpecialParametersSchema.shape,
     excludeCoreServiceFiles: zod_1.z.boolean().optional(),
     validationLibrary: zod_1.z.enum(ValidationLibrary_enum_1.ValidationLibrary).optional(),
-}));
+});
+exports.specialParametersSchemasV4 = zod_1.z.object({
+    ...exports.specialParametersSchemasV3.shape,
+    emptySchemaStrategy: zod_1.z.enum(EmptySchemaStrategy_enum_1.EmptySchemaStrategy).optional(),
+});
 /** Additional parameters */
 exports.additionalParametersSchema = zod_1.z.object({
     clean: zod_1.z.boolean().optional(),

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

@@ -11,12 +11,12 @@ export declare const multiOptionsSchemaV1: z.ZodObject<{
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
-    useOptions: z.ZodOptional<z.ZodBoolean>;
-    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
     exportCore: z.ZodOptional<z.ZodBoolean>;
     exportServices: z.ZodOptional<z.ZodBoolean>;
     exportModels: z.ZodOptional<z.ZodBoolean>;
     exportSchemas: z.ZodOptional<z.ZodBoolean>;
+    useOptions: z.ZodOptional<z.ZodBoolean>;
+    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
     output: z.ZodString;
     outputCore: z.ZodOptional<z.ZodString>;
     outputServices: z.ZodOptional<z.ZodString>;

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

@@ -16,11 +16,11 @@ export declare const multiOptionsSchemaV4: z.ZodObject<{
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
-    useOptions: z.ZodOptional<z.ZodBoolean>;
-    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
     exportCore: z.ZodOptional<z.ZodBoolean>;
     exportServices: z.ZodOptional<z.ZodBoolean>;
     exportModels: z.ZodOptional<z.ZodBoolean>;
     exportSchemas: z.ZodOptional<z.ZodBoolean>;
+    useOptions: z.ZodOptional<z.ZodBoolean>;
+    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 //# sourceMappingURL=MultiOptionsSchemaV4.d.ts.map

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

@@ -7,10 +7,10 @@ export declare const multiOptionsSchemaV5: z.ZodObject<{
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
-    useOptions: z.ZodOptional<z.ZodBoolean>;
-    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
     excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
     includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
+    useOptions: z.ZodOptional<z.ZodBoolean>;
+    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
     items: z.ZodArray<z.ZodObject<{
         input: z.ZodString;
         output: z.ZodString;

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

@@ -8,12 +8,12 @@ export declare const optionsSchemaV1: z.ZodObject<{
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
-    useOptions: z.ZodOptional<z.ZodBoolean>;
-    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
     exportCore: z.ZodOptional<z.ZodBoolean>;
     exportServices: z.ZodOptional<z.ZodBoolean>;
     exportModels: z.ZodOptional<z.ZodBoolean>;
     exportSchemas: z.ZodOptional<z.ZodBoolean>;
+    useOptions: z.ZodOptional<z.ZodBoolean>;
+    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
     output: z.ZodString;
     outputCore: z.ZodOptional<z.ZodString>;
     outputServices: z.ZodOptional<z.ZodString>;

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

@@ -10,10 +10,10 @@ export declare const optionsSchemaV4: z.ZodObject<{
     interfacePrefix: z.ZodOptional<z.ZodString>;
     enumPrefix: z.ZodOptional<z.ZodString>;
     typePrefix: z.ZodOptional<z.ZodString>;
-    useOptions: z.ZodOptional<z.ZodBoolean>;
-    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
     excludeCoreServiceFiles: z.ZodOptional<z.ZodBoolean>;
     includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
+    useOptions: z.ZodOptional<z.ZodBoolean>;
+    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
     output: z.ZodString;
     outputCore: z.ZodOptional<z.ZodString>;
     outputServices: z.ZodOptional<z.ZodString>;

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,EA2EjD,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,EA8FjD,CAAC"}

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

@@ -54,6 +54,19 @@ exports.compatibilityCases = [
         to: 'v3',
         expect: [{ type: 'added', key: 'useCancelableRequest' }],
     },
+    {
+        type: Enums_1.EVersionedSchemaType.MULTI_OPTIONS,
+        from: 'v3',
+        to: 'v4',
+        expect: [
+            { type: 'removed', key: 'output' },
+            { type: 'removed', key: 'outputCore' },
+            { type: 'removed', key: 'outputServices' },
+            { type: 'removed', key: 'outputModels' },
+            { type: 'removed', key: 'outputSchemas' },
+            { type: 'removed', key: 'input' },
+        ],
+    },
     {
         type: Enums_1.EVersionedSchemaType.MULTI_OPTIONS,
         from: 'v4',
@@ -82,4 +95,10 @@ exports.compatibilityCases = [
         to: 'v3',
         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' }]
+    }
 ];

package/dist/common/VersionedSchema/Utils/__tests__/allUtils.test.d.ts

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

package/dist/common/VersionedSchema/Utils/__tests__/allUtils.test.d.ts.map

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