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

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

@@ -1,41 +1,37 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unifiedOptionsSchemaV1 = void 0;
-const joi_1 = __importDefault(require("joi"));
-const HttpClient_enum_1 = require("../../../core/types/enums/HttpClient.enum");
+const zod_1 = require("zod");
 const CommonSchemas_1 = require("../CommonSchemas");
-const mergeObjectSchemas_1 = require("../Utils/mergeObjectSchemas");
-const itemSchema = (0, mergeObjectSchemas_1.mergeObjectSchemas)(joi_1.default.object({
-    input: joi_1.default.string().required().description('Путь, URL или строка OpenAPI спецификации'),
-    request: joi_1.default.string().optional(),
-}), CommonSchemas_1.outputPathsSchema, CommonSchemas_1.additionalParametersSchemaV2, CommonSchemas_1.experimentalParametersSchemaV2);
-/**
- * Unified options schema that supports both single and multi-item configurations.
- * Use either 'items' array for multiple specs OR 'input'/'output' for single spec.
- */
-exports.unifiedOptionsSchemaV1 = (0, mergeObjectSchemas_1.mergeObjectSchemas)(joi_1.default.object({
-    // Multi-item configuration
-    items: joi_1.default.array().items(itemSchema).min(1).optional().description('Массив спецификаций для генерации'),
-    // Single-item configuration (mutually exclusive with items)
-    input: joi_1.default.string()
-        .when('items', {
-        is: joi_1.default.exist(),
-        then: joi_1.default.forbidden(),
-        otherwise: joi_1.default.required(),
-    })
-        .description('Путь, URL или строка OpenAPI спецификации'),
-    output: joi_1.default.string()
-        .when('items', {
-        is: joi_1.default.exist(),
-        then: joi_1.default.forbidden(),
-        otherwise: joi_1.default.required(),
-    })
-        .description('Выходная директория'),
-    httpClient: joi_1.default.string()
-        .valid(...Object.values(HttpClient_enum_1.HttpClient))
-        .optional(),
-}), CommonSchemas_1.outputPathsSchema, // outputCore, outputServices, etc. for single-item mode
-CommonSchemas_1.specialParametersSchemasV2, CommonSchemas_1.additionalParametersSchemaV2, CommonSchemas_1.experimentalParametersSchemaV2).xor('items', 'input');
+const UnifiedBase_1 = require("./UnifiedBase");
+const outputPathsSchemaWithoutOutput = CommonSchemas_1.outputPathsSchema.omit({ output: true });
+exports.unifiedOptionsSchemaV1 = zod_1.z.object({
+    ...UnifiedBase_1.unifiedOptionsShape.shape,
+    ...outputPathsSchemaWithoutOutput.shape,
+    ...CommonSchemas_1.specialParametersSchemasV2.shape,
+    ...CommonSchemas_1.additionalParametersSchemaV2.shape,
+    ...CommonSchemas_1.experimentalParametersSchemaV2.shape,
+});
+/*
+type TUnified = {
+    httpClient: HttpClient.FETCH | HttpClient.XHR | HttpClient.NODE | HttpClient.AXIOS;
+    useCancelableRequest: boolean | undefined;
+    sortByRequired: boolean | undefined;
+    useSeparatedIndexes: boolean | undefined;
+    request: string | undefined;
+    interfacePrefix: string | undefined;
+    enumPrefix: string | undefined;
+    typePrefix: string | undefined;
+    useOptions: boolean | undefined;
+    useUnionTypes: boolean | undefined;
+    excludeCoreServiceFiles: boolean | undefined;
+    includeSchemasFiles: boolean | undefined;
+    outputCore: string | undefined;
+    outputServices: string | undefined;
+    outputModels: string | undefined;
+    outputSchemas: string | undefined;
+    items: { ... 13 more }[] | undefined;
+    input: string | undefined;
+    output: string | undefined;
+}
+*/ 

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

@@ -1,7 +1,38 @@
-import Joi from 'joi';
-/**
- * Unified options schema that supports both single and multi-item configurations.
- * Use either 'items' array for multiple specs OR 'input'/'output' for single spec.
- */
-export declare const unifiedOptionsSchemaV2: Joi.ObjectSchema<any>;
+import { z } from 'zod';
+export declare const unifiedOptionsSchemaV2: 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>;
+    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>;
 //# sourceMappingURL=UnifiedOptionsSchemaV2.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"UnifiedOptionsSchemaV2.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/AllVersionedSchemas/UnifiedOptionsSchemaV2.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAgBtB;;;GAGG;AACH,eAAO,MAAM,sBAAsB,uBA4BZ,CAAC"}
+{"version":3,"file":"UnifiedOptionsSchemaV2.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/AllVersionedSchemas/UnifiedOptionsSchemaV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAKtB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGjC,CAAC"}

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

@@ -1,41 +1,34 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unifiedOptionsSchemaV2 = void 0;
-const joi_1 = __importDefault(require("joi"));
-const HttpClient_enum_1 = require("../../../core/types/enums/HttpClient.enum");
+const zod_1 = require("zod");
 const CommonSchemas_1 = require("../CommonSchemas");
-const mergeObjectSchemas_1 = require("../Utils/mergeObjectSchemas");
-const itemSchema = (0, mergeObjectSchemas_1.mergeObjectSchemas)(joi_1.default.object({
-    input: joi_1.default.string().required().description('Путь, URL или строка OpenAPI спецификации'),
-    request: joi_1.default.string().optional(),
-}), CommonSchemas_1.outputPathsSchema, CommonSchemas_1.additionalParametersSchemaV2, CommonSchemas_1.experimentalParametersSchemaV2);
-/**
- * Unified options schema that supports both single and multi-item configurations.
- * Use either 'items' array for multiple specs OR 'input'/'output' for single spec.
- */
-exports.unifiedOptionsSchemaV2 = (0, mergeObjectSchemas_1.mergeObjectSchemas)(joi_1.default.object({
-    // Multi-item configuration
-    items: joi_1.default.array().items(itemSchema).min(1).optional().description('Массив спецификаций для генерации'),
-    // Single-item configuration (mutually exclusive with items)
-    input: joi_1.default.string()
-        .when('items', {
-        is: joi_1.default.exist(),
-        then: joi_1.default.forbidden(),
-        otherwise: joi_1.default.required(),
-    })
-        .description('Путь, URL или строка OpenAPI спецификации'),
-    output: joi_1.default.string()
-        .when('items', {
-        is: joi_1.default.exist(),
-        then: joi_1.default.forbidden(),
-        otherwise: joi_1.default.required(),
-    })
-        .description('Выходная директория'),
-    httpClient: joi_1.default.string()
-        .valid(...Object.values(HttpClient_enum_1.HttpClient))
-        .optional(),
-}), CommonSchemas_1.outputPathsSchema, // outputCore, outputServices, etc. for single-item mode
-CommonSchemas_1.specialParametersSchemasV3, CommonSchemas_1.additionalParametersSchemaV2, CommonSchemas_1.experimentalParametersSchemaV2).xor('items', 'input');
+const UnifiedOptionsSchemaV1_1 = require("./UnifiedOptionsSchemaV1");
+exports.unifiedOptionsSchemaV2 = zod_1.z.object({
+    ...UnifiedOptionsSchemaV1_1.unifiedOptionsSchemaV1.shape,
+    ...CommonSchemas_1.specialParametersSchemasV3.shape,
+});
+/*
+type TUnified = {
+    output: string;
+    useOptions: boolean | undefined;
+    useUnionTypes: boolean | undefined;
+    excludeCoreServiceFiles: boolean | undefined;
+    validationLibrary: ValidationLibrary.NONE | ValidationLibrary.ZOD | ValidationLibrary.JOI | ValidationLibrary.YUP | ValidationLibrary.JSONSCHEMA | undefined;
+    useCancelableRequest: boolean | undefined;
+    sortByRequired: boolean | undefined;
+    useSeparatedIndexes: boolean | undefined;
+    request: string | undefined;
+    interfacePrefix: string | undefined;
+    enumPrefix: string | undefined;
+    typePrefix: string | undefined;
+    includeSchemasFiles: boolean | undefined;
+    outputCore: string | undefined;
+    outputServices: string | undefined;
+    outputModels: string | undefined;
+    outputSchemas: string | undefined;
+    items: { ... 13 more }[] | undefined;
+    input: string | undefined;
+    httpClient: HttpClient.FETCH | HttpClient.XHR | HttpClient.NODE | HttpClient.AXIOS | undefined;
+}
+*/ 

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const unifiedOptionsSchemaV3: 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>;
+//# sourceMappingURL=UnifiedOptionsSchemaV3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UnifiedOptionsSchemaV3.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/AllVersionedSchemas/UnifiedOptionsSchemaV3.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGjC,CAAC"}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unifiedOptionsSchemaV3 = void 0;
+const zod_1 = require("zod");
+const UnifiedBase_1 = require("./UnifiedBase");
+const UnifiedOptionsSchemaV2_1 = require("./UnifiedOptionsSchemaV2");
+exports.unifiedOptionsSchemaV3 = zod_1.z.object({
+    ...UnifiedOptionsSchemaV2_1.unifiedOptionsSchemaV2.shape,
+    ...UnifiedBase_1.debugSettingsShape.shape,
+});
+/*
+type TUnified = {
+    httpClient: HttpClient.FETCH | HttpClient.XHR | HttpClient.NODE | HttpClient.AXIOS;
+    logLevel: ELogLevel.INFO | ELogLevel.WARN | ELogLevel.ERROR | undefined;
+    logTarget: ELogOutput.CONSOLE | ELogOutput.FILE | undefined;
+    useOptions: boolean | undefined;
+    useUnionTypes: boolean | undefined;
+    excludeCoreServiceFiles: boolean | undefined;
+    validationLibrary: ValidationLibrary.NONE | ValidationLibrary.ZOD | ValidationLibrary.JOI | ValidationLibrary.YUP | ValidationLibrary.JSONSCHEMA | undefined;
+    sortByRequired: boolean | undefined;
+    useSeparatedIndexes: boolean | undefined;
+    useCancelableRequest: boolean | undefined;
+    request: string | undefined;
+    interfacePrefix: string | undefined;
+    enumPrefix: string | undefined;
+    typePrefix: string | undefined;
+    includeSchemasFiles: boolean | undefined;
+    outputCore: string | undefined;
+    outputServices: string | undefined;
+    outputModels: string | undefined;
+    outputSchemas: string | undefined;
+    items: { ... 13 more }[] | undefined;
+    input: string | undefined;
+    output: string | undefined;
+}
+*/

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const unifiedOptionsSchemaV4: 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>;
+//# sourceMappingURL=UnifiedOptionsSchemaV4.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UnifiedOptionsSchemaV4.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/AllVersionedSchemas/UnifiedOptionsSchemaV4.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGjC,CAAA"}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unifiedOptionsSchemaV4 = void 0;
+const zod_1 = require("zod");
+const CommonSchemas_1 = require("../CommonSchemas");
+const UnifiedOptionsSchemaV3_1 = require("./UnifiedOptionsSchemaV3");
+exports.unifiedOptionsSchemaV4 = UnifiedOptionsSchemaV3_1.unifiedOptionsSchemaV3.extend({
+    ...CommonSchemas_1.specialParametersSchemasV4.shape,
+    customExecutorPath: zod_1.z.string().optional(),
+});
+/*
+type TUnified = {
+    httpClient: HttpClient.FETCH | HttpClient.XHR | HttpClient.NODE | HttpClient.AXIOS;
+    logLevel: ELogLevel.INFO | ELogLevel.WARN | ELogLevel.ERROR | undefined;
+    logTarget: ELogOutput.CONSOLE | ELogOutput.FILE | undefined;
+    sortByRequired: boolean | undefined;
+    useSeparatedIndexes: boolean | undefined;
+    useCancelableRequest: boolean | undefined;
+    request: string | undefined;
+    interfacePrefix: string | undefined;
+    enumPrefix: string | undefined;
+    typePrefix: string | undefined;
+    includeSchemasFiles: boolean | undefined;
+    outputCore: string | undefined;
+    outputServices: string | undefined;
+    outputModels: string | undefined;
+    outputSchemas: string | undefined;
+    items: { ... 13 more }[] | undefined;
+    input: string | undefined;
+    output: string | undefined;
+    customExecutorPath: string | undefined;
+    emptySchemaStrategy: EmptySchemaStrategy.SEMANTIC | EmptySchemaStrategy.SKIP | EmptySchemaStrategy.KEEP | undefined;
+    excludeCoreServiceFiles: boolean | undefined;
+    validationLibrary: ValidationLibrary.NONE | ValidationLibrary.ZOD | ValidationLibrary.JOI | ValidationLibrary.YUP | ValidationLibrary.JSONSCHEMA | undefined;
+    useOptions: boolean | undefined;
+    useUnionTypes: boolean | undefined;
+}
+*/ 

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

@@ -0,0 +1,192 @@
+import { z } from 'zod';
+import { VersionedSchema } from '../Types';
+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>;
+        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: "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>;
+    outputModels: z.ZodOptional<z.ZodString>;
+    outputSchemas: z.ZodOptional<z.ZodString>;
+    useOptions: z.ZodOptional<z.ZodBoolean>;
+    useUnionTypes: z.ZodOptional<z.ZodBoolean>;
+    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>;
+    typePrefix: z.ZodOptional<z.ZodString>;
+    useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+    sortByRequired: z.ZodOptional<z.ZodBoolean>;
+    useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
+    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

@@ -0,0 +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;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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatOptionsSchema = exports.rawOptionsSchema = exports.unifiedVersionedSchemas = void 0;
+const zod_1 = require("zod");
+const Enums_1 = require("../Enums");
+const buildVersionedSchema_1 = require("../Utils/buildVersionedSchema");
+const UnifiedOptionsSchemaV1_1 = require("./UnifiedOptionsSchemaV1");
+const UnifiedOptionsSchemaV2_1 = require("./UnifiedOptionsSchemaV2");
+const UnifiedOptionsSchemaV3_1 = require("./UnifiedOptionsSchemaV3");
+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.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'),
+});