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

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

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+export declare const unifiedOptionsSchemaV5: 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>;
+    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>>;
+    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>;
+        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>>;
+        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>;
+    models: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
+        corePath: z.ZodOptional<z.ZodString>;
+        modelsPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    analyze: z.ZodOptional<z.ZodObject<{
+        reportPath: z.ZodOptional<z.ZodString>;
+        useHistory: z.ZodOptional<z.ZodBoolean>;
+        ignore: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+            pattern: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            until: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        failOnBreaking: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    miracles: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            RENAME: "RENAME";
+            TYPE_COERCION: "TYPE_COERCION";
+        }>>>;
+    }, z.core.$strip>>;
+    emptySchemaStrategy: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/EmptySchemaStrategy.enum").EmptySchemaStrategy>>;
+    governanceConfig: z.ZodOptional<z.ZodString>;
+    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>;
+    prettierConfigPath: z.ZodOptional<z.ZodString>;
+    tsconfigPath: z.ZodOptional<z.ZodString>;
+    eslintConfigPath: z.ZodOptional<z.ZodString>;
+    cache: z.ZodOptional<z.ZodBoolean>;
+    cachePath: z.ZodOptional<z.ZodString>;
+    cacheStrategy: z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        entity: "entity";
+    }>>;
+    cacheDebug: z.ZodOptional<z.ZodBoolean>;
+    strictOpenapi: z.ZodOptional<z.ZodBoolean>;
+    reportFile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=UnifiedOptionsSchemaV5.d.ts.map

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unifiedOptionsSchemaV5 = void 0;
+const zod_1 = require("zod");
+const CommonSchemas_1 = require("../CommonSchemas");
+const UnifiedOptionsSchemaV4_1 = require("./UnifiedOptionsSchemaV4");
+exports.unifiedOptionsSchemaV5 = UnifiedOptionsSchemaV4_1.unifiedOptionsSchemaV4.extend({
+    ...CommonSchemas_1.strictModeParametersSchema.shape,
+    prettierConfigPath: zod_1.z.string().optional(),
+    tsconfigPath: zod_1.z.string().optional(),
+    eslintConfigPath: zod_1.z.string().optional(),
+    cache: zod_1.z.boolean().optional(),
+    cachePath: zod_1.z.string().optional(),
+    cacheStrategy: zod_1.z.enum(['content', 'entity']).optional(),
+    cacheDebug: zod_1.z.boolean().optional(),
+});
+/*
+type TUnifiedV5 = TUnifiedV4 & {
+    strictOpenapi: boolean | undefined;
+    reportFile: string | undefined;
+    prettierConfigPath: string | undefined;
+    tsconfigPath: string | undefined;
+    eslintConfigPath: string | undefined;
+    cache: boolean | undefined;
+    cachePath: string | undefined;
+    cacheStrategy: 'content' | 'entity' | undefined;
+    cacheDebug: boolean | undefined;
+}
+*/

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

@@ -8,9 +8,13 @@ declare const unifiedSchemaDefinitions: readonly [{
         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>;
@@ -25,9 +29,13 @@ declare const unifiedSchemaDefinitions: readonly [{
             sortByRequired: z.ZodOptional<z.ZodBoolean>;
             useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
             useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+            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>>;
             output: z.ZodString;
             outputCore: z.ZodOptional<z.ZodString>;
             outputServices: z.ZodOptional<z.ZodString>;
@@ -49,9 +57,13 @@ declare const unifiedSchemaDefinitions: readonly [{
         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>>;
         includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
         outputCore: z.ZodOptional<z.ZodString>;
         outputServices: z.ZodOptional<z.ZodString>;
@@ -63,9 +75,13 @@ declare const unifiedSchemaDefinitions: readonly [{
             sortByRequired: z.ZodOptional<z.ZodBoolean>;
             useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
             useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+            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>>;
             output: z.ZodString;
             outputCore: z.ZodOptional<z.ZodString>;
             outputServices: z.ZodOptional<z.ZodString>;
@@ -89,9 +105,13 @@ declare const unifiedSchemaDefinitions: readonly [{
         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>>;
         includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
         outputCore: z.ZodOptional<z.ZodString>;
         outputServices: z.ZodOptional<z.ZodString>;
@@ -103,9 +123,13 @@ declare const unifiedSchemaDefinitions: readonly [{
             sortByRequired: z.ZodOptional<z.ZodBoolean>;
             useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
             useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+            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>>;
             output: z.ZodString;
             outputCore: z.ZodOptional<z.ZodString>;
             outputServices: z.ZodOptional<z.ZodString>;
@@ -125,9 +149,13 @@ declare const unifiedSchemaDefinitions: readonly [{
         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>>;
         includeSchemasFiles: z.ZodOptional<z.ZodBoolean>;
         outputCore: z.ZodOptional<z.ZodString>;
         outputServices: z.ZodOptional<z.ZodString>;
@@ -139,9 +167,13 @@ declare const unifiedSchemaDefinitions: readonly [{
             sortByRequired: z.ZodOptional<z.ZodBoolean>;
             useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
             useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
+            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>>;
             output: z.ZodString;
             outputCore: z.ZodOptional<z.ZodString>;
             outputServices: z.ZodOptional<z.ZodString>;
@@ -152,12 +184,126 @@ declare const unifiedSchemaDefinitions: readonly [{
         output: z.ZodOptional<z.ZodString>;
         httpClient: z.ZodEnum<typeof import("../../..").HttpClient>;
         customExecutorPath: z.ZodOptional<z.ZodString>;
+        models: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
+            corePath: z.ZodOptional<z.ZodString>;
+            modelsPath: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        analyze: z.ZodOptional<z.ZodObject<{
+            reportPath: z.ZodOptional<z.ZodString>;
+            useHistory: z.ZodOptional<z.ZodBoolean>;
+            ignore: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+                pattern: z.ZodOptional<z.ZodString>;
+                reason: z.ZodOptional<z.ZodString>;
+                until: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            failOnBreaking: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        miracles: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                RENAME: "RENAME";
+                TYPE_COERCION: "TYPE_COERCION";
+            }>>>;
+        }, z.core.$strip>>;
         emptySchemaStrategy: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/EmptySchemaStrategy.enum").EmptySchemaStrategy>>;
+        strictOpenapi: z.ZodOptional<z.ZodBoolean>;
+        reportFile: z.ZodOptional<z.ZodString>;
+        governanceConfig: z.ZodOptional<z.ZodString>;
         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>;
+}, {
+    readonly version: "v5";
+    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>;
+        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>>;
+        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>;
+            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>>;
+            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>;
+        models: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
+            corePath: z.ZodOptional<z.ZodString>;
+            modelsPath: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        analyze: z.ZodOptional<z.ZodObject<{
+            reportPath: z.ZodOptional<z.ZodString>;
+            useHistory: z.ZodOptional<z.ZodBoolean>;
+            ignore: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+                pattern: z.ZodOptional<z.ZodString>;
+                reason: z.ZodOptional<z.ZodString>;
+                until: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            failOnBreaking: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        miracles: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                RENAME: "RENAME";
+                TYPE_COERCION: "TYPE_COERCION";
+            }>>>;
+        }, z.core.$strip>>;
+        emptySchemaStrategy: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/EmptySchemaStrategy.enum").EmptySchemaStrategy>>;
+        governanceConfig: z.ZodOptional<z.ZodString>;
+        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>;
+        prettierConfigPath: z.ZodOptional<z.ZodString>;
+        tsconfigPath: z.ZodOptional<z.ZodString>;
+        eslintConfigPath: z.ZodOptional<z.ZodString>;
+        cache: z.ZodOptional<z.ZodBoolean>;
+        cachePath: z.ZodOptional<z.ZodString>;
+        cacheStrategy: z.ZodOptional<z.ZodEnum<{
+            content: "content";
+            entity: "entity";
+        }>>;
+        cacheDebug: z.ZodOptional<z.ZodBoolean>;
+        strictOpenapi: z.ZodOptional<z.ZodBoolean>;
+        reportFile: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
 }];
 type UnifiedSchemaDefinitions = typeof unifiedSchemaDefinitions;
 type LatestUnifiedDefinition = Last<UnifiedSchemaDefinitions>;
@@ -174,10 +320,17 @@ export declare const flatOptionsSchema: z.ZodObject<{
     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>>;
+    strictOpenapi: z.ZodOptional<z.ZodBoolean>;
+    reportFile: z.ZodOptional<z.ZodString>;
+    governanceConfig: z.ZodOptional<z.ZodString>;
     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>>;
     useCancelableRequest: z.ZodOptional<z.ZodBoolean>;
     sortByRequired: z.ZodOptional<z.ZodBoolean>;
     useSeparatedIndexes: z.ZodOptional<z.ZodBoolean>;
@@ -185,6 +338,38 @@ export declare const flatOptionsSchema: z.ZodObject<{
     logLevel: z.ZodOptional<z.ZodEnum<typeof import("../../Enums").ELogLevel>>;
     logTarget: z.ZodOptional<z.ZodEnum<typeof import("../../Enums").ELogOutput>>;
     customExecutorPath: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<typeof import("../../../core/types/enums/ModelsMode.enum").ModelsMode>>;
+        corePath: z.ZodOptional<z.ZodString>;
+        modelsPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    analyze: z.ZodOptional<z.ZodObject<{
+        reportPath: z.ZodOptional<z.ZodString>;
+        useHistory: z.ZodOptional<z.ZodBoolean>;
+        ignore: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+            pattern: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            until: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        failOnBreaking: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    miracles: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            RENAME: "RENAME";
+            TYPE_COERCION: "TYPE_COERCION";
+        }>>>;
+    }, z.core.$strip>>;
+    prettierConfigPath: z.ZodOptional<z.ZodString>;
+    cache: z.ZodOptional<z.ZodBoolean>;
+    cachePath: z.ZodOptional<z.ZodString>;
+    cacheStrategy: z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        entity: "entity";
+    }>>;
+    cacheDebug: z.ZodOptional<z.ZodBoolean>;
     input: z.ZodString;
     output: z.ZodString;
 }, z.core.$strip>;

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;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"}
+{"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;AAS3C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMpB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASxB,CAAC"}

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

@@ -8,11 +8,13 @@ const UnifiedOptionsSchemaV1_1 = require("./UnifiedOptionsSchemaV1");
 const UnifiedOptionsSchemaV2_1 = require("./UnifiedOptionsSchemaV2");
 const UnifiedOptionsSchemaV3_1 = require("./UnifiedOptionsSchemaV3");
 const UnifiedOptionsSchemaV4_1 = require("./UnifiedOptionsSchemaV4");
+const UnifiedOptionsSchemaV5_1 = require("./UnifiedOptionsSchemaV5");
 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 },
+    { version: 'v5', base: UnifiedOptionsSchemaV5_1.unifiedOptionsSchemaV5 },
 ];
 exports.unifiedVersionedSchemas = unifiedSchemaDefinitions.map(({ version, base }) => (0, buildVersionedSchema_1.buildVersionedSchema)({
     version,
@@ -21,7 +23,13 @@ exports.unifiedVersionedSchemas = unifiedSchemaDefinitions.map(({ version, base
 }));
 const latestUnifiedDefinition = unifiedSchemaDefinitions[unifiedSchemaDefinitions.length - 1];
 exports.rawOptionsSchema = latestUnifiedDefinition.base;
-exports.flatOptionsSchema = exports.rawOptionsSchema.omit({ items: true }).extend({
+exports.flatOptionsSchema = exports.rawOptionsSchema
+    .omit({
+    items: true,
+    tsconfigPath: true,
+    eslintConfigPath: 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,5 +1,6 @@
 import { z } from 'zod';
 import { EmptySchemaStrategy } from '../../core/types/enums/EmptySchemaStrategy.enum';
+import { ModelsMode } from '../../core/types/enums/ModelsMode.enum';
 import { ValidationLibrary } from '../../core/types/enums/ValidationLibrary.enum';
 /** Output paths */
 export declare const outputPathsSchema: z.ZodObject<{
@@ -31,24 +32,63 @@ export declare const specialParametersSchemasV3: z.ZodObject<{
 }, z.core.$strip>;
 export declare const specialParametersSchemasV4: z.ZodObject<{
     emptySchemaStrategy: z.ZodOptional<z.ZodEnum<typeof EmptySchemaStrategy>>;
+    strictOpenapi: z.ZodOptional<z.ZodBoolean>;
+    reportFile: z.ZodOptional<z.ZodString>;
+    governanceConfig: z.ZodOptional<z.ZodString>;
     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 strictModeParametersSchema: z.ZodObject<{
+    strictOpenapi: z.ZodOptional<z.ZodBoolean>;
+    reportFile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /** Additional parameters */
 export declare const additionalParametersSchema: z.ZodObject<{
     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 ModelsMode>>;
+}, z.core.$strip>;
+export declare const modelsConfigSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<typeof ModelsMode>>;
+    corePath: z.ZodOptional<z.ZodString>;
+    modelsPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const analyzeConfigSchema: z.ZodObject<{
+    reportPath: z.ZodOptional<z.ZodString>;
+    useHistory: z.ZodOptional<z.ZodBoolean>;
+    ignore: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        pattern: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    failOnBreaking: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const miraclesConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        RENAME: "RENAME";
+        TYPE_COERCION: "TYPE_COERCION";
+    }>>>;
 }, z.core.$strip>;
 export declare const additionalParametersSchemaV2: z.ZodObject<{
     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 ModelsMode>>;
 }, z.core.$strip>;
 /** Experimental parameters */
 export declare const experimentalParametersSchema: 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,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"}
+{"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,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,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;;;;;;;;;iBAMrC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAC;AAEH,4BAA4B;AAE5B,eAAO,MAAM,0BAA0B;;;;;;;;;;iBAUrC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;iBAc9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;iBAI/B,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,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,48 @@ 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/MultiOptionsSchemaV2.js

@@ -29,4 +29,4 @@ type TMulti = {
     typePrefix: string | undefined;
     httpClient: HttpClient.FETCH | HttpClient.XHR | HttpClient.NODE | HttpClient.AXIOS | undefined;
 }
-*/ 
+*/