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

package/README.md

@@ -64,7 +64,6 @@ openapi generate --input ./spec.json --output ./dist
 | `--useOptions` | - | boolean | `false` | Use options instead of arguments |
 | `--useUnionTypes` | - | boolean | `false` | Use union types instead of enums |
 | `--excludeCoreServiceFiles` | - | boolean | `false` | Exclude generation of core and service files |
-| `--includeSchemasFiles` | - | boolean | `false` | Enable generation of model validation schemas |
 | `--request` | - | string | - | Path to custom request file |
 | `--interfacePrefix` | - | string | `I` | Prefix for interface models |
 | `--enumPrefix` | - | string | `E` | Prefix for enum models |
@@ -74,6 +73,7 @@ openapi generate --input ./spec.json --output ./dist
 | `--useSeparatedIndexes` | - | boolean | `false` | Use separate index files for core, models, schemas, and services |
 | `--logLevel` | `-l` | string | `error` | Logging level: `info`, `warn`, or `error` |
 | `--logTarget` | `-t` | string | `console` | Logging target: `console` or `file` |
+| `--validationLibrary` | - | string | `none` | Validation library for schema generation: `none`, `zod`, `joi`, `yup`, or `jsonschema` |
 
 **Examples:**
 ```bash
@@ -93,7 +93,6 @@ openapi generate \
   --httpClient fetch \
   --useOptions \
   --useUnionTypes \
-  --includeSchemasFiles \
   --logLevel info
 ```
 
@@ -143,7 +142,6 @@ Instead of passing all options via CLI, you can use a configuration file. Create
     "useOptions": false,
     "useUnionTypes": false,
     "excludeCoreServiceFiles": false,
-    "includeSchemasFiles": false,
     "interfacePrefix": "I",
     "enumPrefix": "E",
     "typePrefix": "T",
@@ -160,7 +158,6 @@ Instead of passing all options via CLI, you can use a configuration file. Create
     "output": "./dist",
     "client": "fetch",
     "excludeCoreServiceFiles": true,
-    "includeSchemasFiles": true,
     "items": [
         {
             "input": "./first.yml"
@@ -201,7 +198,6 @@ Instead of passing all options via CLI, you can use a configuration file. Create
 | `useOptions` | boolean | `false` | Use options instead of arguments |
 | `useUnionTypes` | boolean | `false` | Use union types instead of enums |
 | `excludeCoreServiceFiles` | boolean | `false` | Exclude core and service files generation |
-| `includeSchemasFiles` | boolean | `false` | Enable model validation schemas generation |
 | `request` | string | - | Path to custom request file |
 | `interfacePrefix` | string | `I` | Prefix for interface models |
 | `enumPrefix` | string | `E` | Prefix for enum models |
@@ -210,6 +206,7 @@ Instead of passing all options via CLI, you can use a configuration file. Create
 | `sortByRequired` | boolean | `false` | Extended sorting strategy for arguments |
 | `useSeparatedIndexes` | boolean | `false` | Use separate index files |
 | `items` | array | - | Array of configurations (for multi-options format) |
+| `validationLibrary` | string | `none` | Validation library for schema generation: `none`, `zod`, `joi`, `yup`, or `jsonschema` |
 
 **Note:** You can use the `init-openapi-config` command to generate a template configuration file.
 
@@ -369,11 +366,19 @@ const order: Order = {
 }
 ```
 
-### Runtime schemas `--includeSchemasFiles`
+### Validation schemas `--validationLibrary`
 By default, the OpenAPI generator only exports interfaces for your models. These interfaces will help you during
-development, but will not be available in JavaScript during runtime. However, Swagger allows you to define properties
-that can be useful during runtime, for instance: `maxLength` of a string or a `pattern` to match, etc. Let's say
-we have the following model:
+development, but will not be available in JavaScript during runtime. However, OpenAPI allows you to define properties
+that can be useful during runtime, for instance: `maxLength` of a string or a `pattern` to match, etc.
+
+The `--validationLibrary` parameter allows you to generate runtime validation schemas using popular validation libraries:
+- **none** (default) - No validation schemas generated
+- **zod** - Generate Zod validation schemas
+- **joi** - Generate Joi validation schemas
+- **yup** - Generate Yup validation schemas
+- **jsonschema** - Generate JSON Schema validation schemas
+
+Let's say we have the following model:
 
 ```json
 {
@@ -407,77 +412,88 @@ we have the following model:
 }
 ```
 
-This will generate the following interface:
+**With Zod (`--validationLibrary zod`):**
 
-```typescript
-export interface MyModel {
-    key: string;
-    name: string;
-    readonly enabled?: boolean;
-    readonly modified?: string;
+```ts
+import { z } from 'zod';
+
+export const MyModelSchema = z.object({
+    key: z.string().max(64).regex(/^[a-zA-Z0-9_]*$/),
+    name: z.string().max(255),
+    enabled: z.boolean().readonly().optional(),
+    modified: z.string().datetime().readonly().optional(),
+});
+
+export type MyModel = z.infer<typeof MyModelSchema>;
+
+export function validateMyModel(data: unknown): MyModel {
+    return MyModelSchema.parse(data);
+}
+
+export function safeValidateMyModel(data: unknown): { success: true; data: MyModel } | { success: false; error: z.ZodError } {
+    const result = MyModelSchema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error };
 }
 ```
 
-The interface does not contain any properties like `maxLength` or `pattern`. However, they could be useful
-if we wanted to create some form where a user could create such a model. In that form you would iterate
-over the properties to render form fields based on their type and validate the input based on the `maxLength`
-or `pattern` property. This requires us to have this information somewhere... For this we can use the
-flag `--includeSchemasFiles` to generate a runtime model next to the normal interface:
+**With Joi (`--validationLibrary joi`):**
 
-```typescript
-export const $MyModel = {
+```ts
+import Joi from 'joi';
+
+export const MyModelSchema = Joi.object({
+    key: Joi.string().max(64).pattern(/^[a-zA-Z0-9_]*$/).required(),
+    name: Joi.string().max(255).required(),
+    enabled: Joi.boolean().readonly(),
+    modified: Joi.string().isoDate().readonly(),
+});
+```
+
+**With Yup (`--validationLibrary yup`):**
+
+```ts
+import * as yup from 'yup';
+
+export const MyModelSchema = yup.object({
+    key: yup.string().max(64).matches(/^[a-zA-Z0-9_]*$/).required(),
+    name: yup.string().max(255).required(),
+    enabled: yup.boolean().readonly(),
+    modified: yup.string().datetime().readonly(),
+});
+```
+
+**With JSON Schema (`--validationLibrary jsonschema`):**
+
+```ts
+export const MyModelSchema = {
+    type: 'object',
+    required: ['key', 'name'],
     properties: {
         key: {
             type: 'string',
-            isRequired: true,
             maxLength: 64,
             pattern: '^[a-zA-Z0-9_]*$',
         },
         name: {
             type: 'string',
-            isRequired: true,
             maxLength: 255,
         },
         enabled: {
             type: 'boolean',
-            isReadOnly: true,
+            readOnly: true,
         },
         modified: {
             type: 'string',
-            isReadOnly: true,
             format: 'date-time',
+            readOnly: true,
         },
     },
 };
 ```
-
-These runtime object are prefixed with a `$` character and expose all the interesting attributes of a model
-and its properties. We can now use this object to generate the form:
-
-```typescript jsx
-import { $MyModel } from './generated';
-
-// Some pseudo code to iterate over the properties and return a form field
-// the form field could be some abstract component that renders the correct
-// field type and validation rules based on the given input.
-const formFields = Object.entries($MyModel.properties).map(([key, value]) => (
-    <FormField
-        name={key}
-        type={value.type}
-        format={value.format}
-        maxLength={value.maxLength}
-        pattern={value.pattern}
-        isReadOnly={value.isReadOnly}
-    />
-));
-
-const MyForm = () => (
-    <form>
-        {formFields}
-    </form>
-);
-
-```
+These validation schemas can be used for form generation, input validation, and runtime type checking in your application.
 
 ### Cancelable promise `--useCancelableRequest`
 By default, the OpenAPI generator generates services for accessing the API that use non-cancellable requests. Therefore, we have added the ability to switch the generator to generate canceled API requests. To do this, use the flag `--useCancelableRequest`.

package/README.rus.md

@@ -63,7 +63,6 @@ openapi generate --input ./spec.json --output ./dist
 | `--useOptions` | - | boolean | `false` | Использовать опции вместо аргументов |
 | `--useUnionTypes` | - | boolean | `false` | Использовать union типы вместо enums |
 | `--excludeCoreServiceFiles` | - | boolean | `false` | Исключить генерацию core и сервисных файлов |
-| `--includeSchemasFiles` | - | boolean | `false` | Включить генерацию схем валидации моделей |
 | `--request` | - | string | - | Путь к пользовательскому файлу запросов |
 | `--interfacePrefix` | - | string | `I` | Префикс для интерфейсов моделей |
 | `--enumPrefix` | - | string | `E` | Префикс для enum моделей |
@@ -73,6 +72,7 @@ openapi generate --input ./spec.json --output ./dist
 | `--useSeparatedIndexes` | - | boolean | `false` | Использовать отдельные index файлы для core, models, schemas и services |
 | `--logLevel` | `-l` | string | `error` | Уровень логирования: `info`, `warn`, или `error` |
 | `--logTarget` | `-t` | string | `console` | Цель логирования: `console` или `file` |
+| `--validationLibrary` | - | string | `none` | Библиотека валидации для генерации схем: `none`, `zod`, `joi`, `yup`, или `jsonschema` |
 
 **Примеры:**
 ```bash
@@ -92,7 +92,6 @@ openapi generate \
   --httpClient fetch \
   --useOptions \
   --useUnionTypes \
-  --includeSchemasFiles \
   --logLevel info
 ```
 
@@ -142,7 +141,6 @@ openapi init-openapi-config --openapi-config ./my-config.json
     "useOptions": false,
     "useUnionTypes": false,
     "excludeCoreServiceFiles": false,
-    "includeSchemasFiles": false,
     "interfacePrefix": "I",
     "enumPrefix": "E",
     "typePrefix": "T",
@@ -159,7 +157,6 @@ openapi init-openapi-config --openapi-config ./my-config.json
     "output": "./dist",
     "client": "fetch",
     "excludeCoreServiceFiles": true,
-    "includeSchemasFiles": true,
     "items": [
         {
             "input": "./first.yml"
@@ -200,7 +197,6 @@ openapi init-openapi-config --openapi-config ./my-config.json
 | `useOptions` | boolean | `false` | Использовать опции вместо аргументов |
 | `useUnionTypes` | boolean | `false` | Использовать union типы вместо enums |
 | `excludeCoreServiceFiles` | boolean | `false` | Исключить генерацию core и сервисных файлов |
-| `includeSchemasFiles` | boolean | `false` | Включить генерацию схем валидации моделей |
 | `request` | string | - | Путь к пользовательскому файлу запросов |
 | `interfacePrefix` | string | `I` | Префикс для интерфейсов моделей |
 | `enumPrefix` | string | `E` | Префикс для enum моделей |
@@ -209,6 +205,7 @@ openapi init-openapi-config --openapi-config ./my-config.json
 | `sortByRequired` | boolean | `false` | Расширенная стратегия сортировки для аргументов |
 | `useSeparatedIndexes` | boolean | `false` | Использовать отдельные index файлы |
 | `items` | array | - | Массив конфигураций (для формата multi-options) |
+| `validationLibrary` | string | `none` | Библиотека валидации для генерации схем: `none`, `zod`, `joi`, `yup`, или `jsonschema` |
 
 **Примечание:** Вы можете использовать команду `init-openapi-config` для генерации шаблона файла конфигурации.
 
@@ -368,11 +365,19 @@ const order: Order = {
 }
 ```
 
-### Runtime схемы `--includeSchemasFiles`
+### Схемы проверки `--validationLibrary`
 По умолчанию генератор OpenAPI экспортирует только интерфейсы для ваших моделей. Эти интерфейсы помогут вам во время
-разработки, но не будут доступны в JavaScript во время выполнения. Однако Swagger позволяет определять свойства,
-которые могут быть полезны во время выполнения, например: `maxLength` строки или `pattern` для сопоставления и т.д. Допустим,
-у нас есть следующая модель:
+разработки, но не будут доступны в JavaScript во время выполнения. Однако OpenAPI позволяет определять свойства,
+которые могут быть полезны во время выполнения, например: `maxLength` строки или `pattern` для сопоставления и т.д.
+
+Параметр `--validationLibrary` позволяет генерировать схемы валидации времени выполнения с использованием популярных библиотек валидации:
+- **none** (по умолчанию) - Схемы валидации не генерируются
+- **zod** - Генерация схем валидации Zod
+- **joi** - Генерация схем валидации Joi
+- **yup** - Генерация схем валидации Yup
+- **jsonschema** - Генерация схем валидации JSON Schema
+
+Допустим, у нас есть следующая модель:
 
 ```json
 {
@@ -406,77 +411,89 @@ const order: Order = {
 }
 ```
 
-Это сгенерирует следующий интерфейс:
+**С Zod (`--validationLibrary zod`):**
 
-```typescript
-export interface MyModel {
-    key: string;
-    name: string;
-    readonly enabled?: boolean;
-    readonly modified?: string;
+```ts
+import { z } from 'zod';
+
+export const MyModelSchema = z.object({
+    key: z.string().max(64).regex(/^[a-zA-Z0-9_]*$/),
+    name: z.string().max(255),
+    enabled: z.boolean().readonly().optional(),
+    modified: z.string().datetime().readonly().optional(),
+});
+
+export type MyModel = z.infer<typeof MyModelSchema>;
+
+export function validateMyModel(data: unknown): MyModel {
+    return MyModelSchema.parse(data);
+}
+
+export function safeValidateMyModel(data: unknown): { success: true; data: MyModel } | { success: false; error: z.ZodError } {
+    const result = MyModelSchema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error };
 }
 ```
 
-Интерфейс не содержит таких свойств, как `maxLength` или `pattern`. Однако они могут быть полезны,
-если мы хотим создать форму, где пользователь может создать такую модель. В этой форме вы будете итерироваться
-по свойствам для рендеринга полей формы на основе их типа и валидации ввода на основе свойства `maxLength`
-или `pattern`. Для этого нам нужно где-то хранить эту информацию... Для этого мы можем использовать
-флаг `--includeSchemasFiles` для генерации runtime модели рядом с обычным интерфейсом:
+**С Joi (`--validationLibrary joi`):**
 
-```typescript
-export const $MyModel = {
+```ts
+import Joi from 'joi';
+
+export const MyModelSchema = Joi.object({
+    key: Joi.string().max(64).pattern(/^[a-zA-Z0-9_]*$/).required(),
+    name: Joi.string().max(255).required(),
+    enabled: Joi.boolean().readonly(),
+    modified: Joi.string().isoDate().readonly(),
+});
+```
+
+**С Yup (`--validationLibrary yup`):**
+
+```ts
+import * as yup from 'yup';
+
+export const MyModelSchema = yup.object({
+    key: yup.string().max(64).matches(/^[a-zA-Z0-9_]*$/).required(),
+    name: yup.string().max(255).required(),
+    enabled: yup.boolean().readonly(),
+    modified: yup.string().datetime().readonly(),
+});
+```
+
+**С JSON Schema (`--validationLibrary jsonschema`):**
+
+```ts
+export const MyModelSchema = {
+    type: 'object',
+    required: ['key', 'name'],
     properties: {
         key: {
             type: 'string',
-            isRequired: true,
             maxLength: 64,
             pattern: '^[a-zA-Z0-9_]*$',
         },
         name: {
             type: 'string',
-            isRequired: true,
             maxLength: 255,
         },
         enabled: {
             type: 'boolean',
-            isReadOnly: true,
+            readOnly: true,
         },
         modified: {
             type: 'string',
-            isReadOnly: true,
             format: 'date-time',
+            readOnly: true,
         },
     },
 };
 ```
 
-Эти runtime объекты имеют префикс `$` и раскрывают все интересные атрибуты модели
-и её свойств. Теперь мы можем использовать этот объект для генерации формы:
-
-```typescript jsx
-import { $MyModel } from './generated';
-
-// Псевдокод для итерации по свойствам и возврата поля формы
-// поле формы может быть абстрактным компонентом, который рендерит правильный
-// тип поля и правила валидации на основе заданного ввода.
-const formFields = Object.entries($MyModel.properties).map(([key, value]) => (
-    <FormField
-        name={key}
-        type={value.type}
-        format={value.format}
-        maxLength={value.maxLength}
-        pattern={value.pattern}
-        isReadOnly={value.isReadOnly}
-    />
-));
-
-const MyForm = () => (
-    <form>
-        {formFields}
-    </form>
-);
-
-```
+Эти схемы валидации могут быть использованы для генерации форм, валидации ввода и проверки типов во время выполнения в вашем приложении.
 
 ### Отменяемый promise `--useCancelableRequest`
 По умолчанию генератор OpenAPI генерирует сервисы для доступа к API, которые используют неотменяемые запросы. Поэтому мы добавили возможность переключить генератор на генерацию отменяемых API запросов. Для этого используйте флаг `--useCancelableRequest`.

package/dist/cli/generate/runGenerateOpenApi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runGenerateOpenApi.d.ts","sourceRoot":"","sources":["../../../src/cli/generate/runGenerateOpenApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAYzC;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAwC7E"}
+{"version":3,"file":"runGenerateOpenApi.d.ts","sourceRoot":"","sources":["../../../src/cli/generate/runGenerateOpenApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAgBzC;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA8D7E"}

package/dist/cli/generate/runGenerateOpenApi.js

@@ -37,12 +37,15 @@ exports.runGenerateOpenApi = runGenerateOpenApi;
 const Consts_1 = require("../../common/Consts");
 const defaultOptions_1 = require("../../common/defaultOptions");
 const Enums_1 = require("../../common/Enums");
+const LoggerMessages_1 = require("../../common/LoggerMessages");
 const convertArrayToObject_1 = require("../../common/utils/convertArrayToObject");
 const loadConfigIfExists_1 = require("../../common/utils/loadConfigIfExists");
 const AllMigrationPlans_1 = require("../../common/VersionedSchema/AllVersionedSchemas/AllMigrationPlans");
 const AllVersionedSchemas_1 = require("../../common/VersionedSchema/AllVersionedSchemas/AllVersionedSchemas");
 const migrateDataToLatestSchemaVersion_1 = require("../../common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion");
 const OpenAPI = __importStar(require("../../core"));
+const generate_1 = require("../schemas/generate");
+const validation_1 = require("../validation");
 /**
  * Запускает генерацию OpenAPI клиента
  * Поддерживает как конфиг-файл, так и параметры из CLI
@@ -50,17 +53,35 @@ const OpenAPI = __importStar(require("../../core"));
 async function runGenerateOpenApi(options) {
     const { openapiConfig, ...clientOptions } = options;
     try {
-        const hasMinimumRequiredOptions = !!clientOptions.input && !!clientOptions.output;
+        // Валидация опций через Zod
+        const validationResult = (0, validation_1.validateCLIOptions)(generate_1.generateOptionsSchema, {
+            openapiConfig,
+            ...clientOptions,
+        });
+        if (!validationResult.success) {
+            Consts_1.APP_LOGGER.error(validationResult.error);
+            process.exit(1);
+        }
+        const validatedOptions = validationResult.data;
+        // Если есть минимальные опции (input и output), используем их
+        const hasMinimumRequiredOptions = !!validatedOptions.input && !!validatedOptions.output;
         if (hasMinimumRequiredOptions) {
-            const { error: defaultValuesError, value } = defaultOptions_1.defaultOptions.validate(clientOptions);
+            // Используем старую Joi валидацию для обратной совместимости
+            // В будущем можно заменить на Zod
+            const { error: defaultValuesError, value } = defaultOptions_1.defaultOptions.validate({
+                input: validatedOptions.input,
+                output: validatedOptions.output,
+                ...clientOptions,
+            });
             if (defaultValuesError) {
                 await OpenAPI.generate(value);
                 process.exit(0);
             }
         }
-        const configData = (0, loadConfigIfExists_1.loadConfigIfExists)(openapiConfig);
+        const configData = (0, loadConfigIfExists_1.loadConfigIfExists)(validatedOptions.openapiConfig);
         if (!configData) {
-            Consts_1.APP_LOGGER.error('The configuration file is missing');
+            Consts_1.APP_LOGGER.error(LoggerMessages_1.LOGGER_MESSAGES.CONFIG.FILE_MISSING);
+            process.exit(1);
         }
         const preparedOptions = (0, convertArrayToObject_1.convertArrayToObject)(configData);
         // Use unified migration system for all schema types
@@ -71,15 +92,15 @@ async function runGenerateOpenApi(options) {
             migrationMode: Enums_1.EMigrationMode.GENERATE_OPENAPI,
         });
         if (!migratedOptions) {
-            Consts_1.APP_LOGGER.error("Couldn't convert the set of options to the current version");
-        }
-        else {
-            const { value } = migratedOptions;
-            await OpenAPI.generate(value);
+            Consts_1.APP_LOGGER.error(LoggerMessages_1.LOGGER_MESSAGES.CONFIG.CONVERSION_FAILED);
+            process.exit(1);
         }
+        const { value } = migratedOptions;
+        await OpenAPI.generate(value);
         process.exit(0);
     }
     catch (error) {
         Consts_1.APP_LOGGER.error(error.message);
+        process.exit(1);
     }
 }

package/dist/cli/index.js

@@ -11,6 +11,7 @@ const Enums_1 = require("../common/Enums");
 const UpdateNotifier_1 = require("../common/UpdateNotifier");
 const pathHelpers_1 = require("../common/utils/pathHelpers");
 const HttpClient_enum_1 = require("../core/types/enums/HttpClient.enum");
+const ValidationLibrary_enum_1 = require("../core/types/enums/ValidationLibrary.enum");
 const checkConfig_1 = require("./checkAndUpdateConfig/checkConfig");
 const updateConfig_1 = require("./checkAndUpdateConfig/updateConfig");
 const runGenerateOpenApi_1 = require("./generate/runGenerateOpenApi");
@@ -46,7 +47,6 @@ program
     .option('--useOptions', 'Use options instead of arguments (default: false)')
     .option('--useUnionTypes', 'Use union types instead of enums (default: false)')
     .option('--excludeCoreServiceFiles', 'The generation of the core and services is excluded (default: false)')
-    .option('--includeSchemasFiles', 'The generation of model validation schemes is enabled (default: false)')
     .option('--request <value>', 'Path to custom request file')
     .option('--interfacePrefix <value>', 'Prefix for interface model(default: "I")', 'I')
     .option('--enumPrefix <value>', 'Prefix for enum model(default: "E")', 'E')
@@ -56,6 +56,7 @@ program
     .addOption(new commander_1.Option('-t, --logTarget <target>', 'Target of logging').choices([...Object.values(Enums_1.ELogOutput)]).default(Enums_1.ELogOutput.CONSOLE))
     .option('-s, --sortByRequired', 'Property sorting strategy: simplified or extended')
     .option('--useSeparatedIndexes', 'Use separate index files for the core, models, schemas, and services.')
+    .addOption(new commander_1.Option('--validationLibrary <value>', 'Validation library to use for schema validation').choices([...Object.values(ValidationLibrary_enum_1.ValidationLibrary)]).default(ValidationLibrary_enum_1.ValidationLibrary.NONE))
     .hook('preAction', async () => {
     await updateNotifier.checkAndNotify();
 })

package/dist/cli/schemas/base.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ELogLevel, ELogOutput } from '../../common/Enums';
+import { HttpClient } from '../../core/types/enums/HttpClient.enum';
+/**
+ * Базовая схема с общими опциями для всех команд
+ */
+export declare const baseCLIOptionsSchema: z.ZodObject<{
+    openapiConfig: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type BaseCLIOptions = z.infer<typeof baseCLIOptionsSchema>;
+/**
+ * Enum схемы для типизированных значений
+ */
+export declare const httpClientSchema: z.ZodEnum<typeof HttpClient>;
+export declare const logLevelSchema: z.ZodEnum<typeof ELogLevel>;
+export declare const logTargetSchema: z.ZodEnum<typeof ELogOutput>;
+//# sourceMappingURL=base.d.ts.map

package/dist/cli/schemas/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/cli/schemas/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAEpE;;GAEG;AACH,eAAO,MAAM,oBAAoB;;iBAE/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,gBAAgB,8BAA2B,CAAC;AACzD,eAAO,MAAM,cAAc,6BAA0B,CAAC;AACtD,eAAO,MAAM,eAAe,8BAA2B,CAAC"}

package/dist/cli/schemas/base.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logTargetSchema = exports.logLevelSchema = exports.httpClientSchema = exports.baseCLIOptionsSchema = void 0;
+const zod_1 = require("zod");
+const Consts_1 = require("../../common/Consts");
+const Enums_1 = require("../../common/Enums");
+const HttpClient_enum_1 = require("../../core/types/enums/HttpClient.enum");
+/**
+ * Базовая схема с общими опциями для всех команд
+ */
+exports.baseCLIOptionsSchema = zod_1.z.object({
+    openapiConfig: zod_1.z.string().optional().default(Consts_1.DEFAULT_OPENAPI_CONFIG_FILENAME),
+});
+/**
+ * Enum схемы для типизированных значений
+ */
+exports.httpClientSchema = zod_1.z.nativeEnum(HttpClient_enum_1.HttpClient);
+exports.logLevelSchema = zod_1.z.nativeEnum(Enums_1.ELogLevel);
+exports.logTargetSchema = zod_1.z.nativeEnum(Enums_1.ELogOutput);

package/dist/cli/schemas/checkConfig.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const checkConfigOptionsSchema: z.ZodObject<{
+    openapiConfig: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type CheckConfigOptions = z.infer<typeof checkConfigOptionsSchema>;
+//# sourceMappingURL=checkConfig.d.ts.map

package/dist/cli/schemas/checkConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkConfig.d.ts","sourceRoot":"","sources":["../../../src/cli/schemas/checkConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,wBAAwB;;iBAAuB,CAAC;AAE7D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/cli/schemas/checkConfig.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConfigOptionsSchema = void 0;
+const base_1 = require("./base");
+exports.checkConfigOptionsSchema = base_1.baseCLIOptionsSchema;

package/dist/cli/schemas/generate.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/**
+ * Схема для команды generate
+ * Основана на baseFlatOptionsSchema, но с добавлением:
+ * - openapiConfig (из baseCLIOptionsSchema)
+ * - опциональными input/output (валидируются условно)
+ */
+export declare const generateOptionsSchema: z.ZodObject<{
+    openapiConfig: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    outputCore: z.ZodOptional<z.ZodString>;
+    outputServices: z.ZodOptional<z.ZodString>;
+    outputModels: z.ZodOptional<z.ZodString>;
+    outputSchemas: z.ZodOptional<z.ZodString>;
+    interfacePrefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    enumPrefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    typePrefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    httpClient: z.ZodOptional<z.ZodEnum<typeof import("../..").HttpClient>>;
+    useOptions: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    useUnionTypes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    excludeCoreServiceFiles: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    request: z.ZodOptional<z.ZodString>;
+    useCancelableRequest: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logLevel: z.ZodOptional<z.ZodEnum<typeof import("../../common/Enums").ELogLevel>>;
+    logTarget: z.ZodOptional<z.ZodEnum<typeof import("../../common/Enums").ELogOutput>>;
+    sortByRequired: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    useSeparatedIndexes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    validationLibrary: z.ZodOptional<z.ZodEnum<typeof import("../../core/types/enums/ValidationLibrary.enum").ValidationLibrary>>;
+    input: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodString>>;
+    output: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type GenerateOptions = z.infer<typeof generateOptionsSchema>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/cli/schemas/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/cli/schemas/generate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;iBAwC5B,CAAC;AAEP,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}