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

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`.
@@ -510,6 +526,110 @@ export function request<T>(config: TOpenAPIConfig, options: ApiRequestOptions):
 }
 ```
 
+### RequestExecutor
+
+Starting from version **2.0.0** the generated services use the `RequestExecutor` interface
+instead of direct calls to the `request` core function.
+
+The `RequestExecutor` is a single HTTP logic integration point responsible for executing requests
+and extending client behavior. It allows you to:
+- use any transport (fetch/axios/xhr/custom);
+- Centrally handle requests, responses, and errors;
+- expand the client's behavior without changing the generated services.
+
+#### Interceptors
+
+`RequestExecutor` supports **interceptors**, which allow you to implement additional
+logic at different stages of the request lifecycle.:
+
+- `onRequest` — modification of the request before sending (headers, auth, logging);
+- `onResponse` — processing successful responses;
+- `onError` — centralized error handling.
+
+Interceptors are applied at the executor level and are automatically used by all
+generated services.
+
+```ts
+import { createClient } from './generated';
+
+const client = createClient({
+    interceptors: {
+        onRequest: [
+            (config) => ({
+                ...config,
+                headers: {
+                    ...config.headers,
+                    Authorization: 'Bearer token',
+                },
+            }),
+        ],
+        onError: [
+            (error) => {
+                console.error(error);
+                throw error;
+            },
+        ],
+    },
+});
+```
+
+#### Custom implementation of RequestExecutor with interceptors
+
+A custom `RequestExecutor` can be used together with interceptors.
+In this case, the executor is responsible only for the transport and execution of the request,
+while the interceptors are responsible for the extensible business logic (authorization, logging, error handling).
+
+```ts
+import type { RequestExecutor, RequestConfig } from './generated/core/executor/requestExecutor';
+import { withInterceptors } from './generated/core/interceptors/withInterceptors';
+import { SimpleService } from './generated/services/SimpleService';
+
+interface MyCustomOptions {
+    timeout?: number;
+}
+
+const baseExecutor: RequestExecutor<MyCustomOptions> = {
+    async request<T>(config: RequestConfig, options?: MyCustomOptions): Promise<T> {
+        const response = await fetch(config.url, {
+            method: config.method,
+            headers: config.headers,
+            body: config.body ? JSON.stringify(config.body) : undefined,
+            signal: options?.timeout
+                ? AbortSignal.timeout(options.timeout)
+                : undefined,
+        });
+
+        if (!response.ok) {
+            throw new Error(`Request failed: ${response.status}`);
+        }
+
+        return response.json();
+    },
+};
+
+// Wrapping the executor interceptors
+const executor = withInterceptors(baseExecutor, {
+    onRequest: [
+        (config) => ({
+            ...config,
+            headers: {
+                ...config.headers,
+                Authorization: 'Bearer token',
+            },
+        }),
+    ],
+    onError: [
+        (error) => {
+            console.error(error);
+            throw error;
+        },
+    ],
+});
+
+const service = new SimpleService(executor);
+await service.getCallWithoutParametersAndResponse({ timeout: 5000 });
+```
+
 ### Sorting strategy for function arguments `--sortByRequired`
 By default, the OpenAPI generator sorts the parameters of service functions according to a simplified scheme. If you need a more strict sorting option, then you need to use the `--sortByRequired` flag. The simplified sorting option is similar to the one used in version 0.2.3 of the OpenAPI generator. This flag allows you to upgrade to a new version of the generator if you are "stuck" on version 0.2.3.
 

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`.
@@ -509,6 +526,110 @@ export function request<T>(config: TOpenAPIConfig, options: ApiRequestOptions):
 }
 ```
 
+### RequestExecutor
+
+Начиная с версии **2.0.0**, сгенерированные сервисы используют интерфейс `RequestExecutor`
+вместо прямых вызовов core-функции `request`.
+
+`RequestExecutor` — это единая точка интеграции HTTP-логики, отвечающая за выполнение запросов
+и расширение поведения клиента. Он позволяет:
+- использовать любой транспорт (fetch / axios / xhr / custom);
+- централизованно обрабатывать запросы, ответы и ошибки;
+- расширять поведение клиента без изменения сгенерированных сервисов.
+
+#### Interceptors
+
+`RequestExecutor` поддерживает **interceptors**, которые позволяют внедрять дополнительную
+логику на разных этапах жизненного цикла запроса:
+
+- `onRequest` — модификация запроса перед отправкой (headers, auth, логирование);
+- `onResponse` — обработка успешных ответов;
+- `onError` — централизованная обработка ошибок.
+
+Interceptors применяются на уровне executor’а и автоматически используются всеми
+сгенерированными сервисами.
+
+```ts
+import { createClient } from './generated';
+
+const client = createClient({
+    interceptors: {
+        onRequest: [
+            (config) => ({
+                ...config,
+                headers: {
+                    ...config.headers,
+                    Authorization: 'Bearer token',
+                },
+            }),
+        ],
+        onError: [
+            (error) => {
+                console.error(error);
+                throw error;
+            },
+        ],
+    },
+});
+```
+
+#### Пользовательская реализация RequestExecutor с interceptors
+
+Пользовательский `RequestExecutor` может быть использован вместе с interceptors.
+В этом случае executor отвечает только за транспорт и выполнение запроса,
+а interceptors — за расширяемую бизнес-логику (авторизация, логирование, обработка ошибок).
+
+```ts
+import type { RequestExecutor, RequestConfig } from './generated/core/executor/requestExecutor';
+import { withInterceptors } from './generated/core/interceptors/withInterceptors';
+import { SimpleService } from './generated/services/SimpleService';
+
+interface MyCustomOptions {
+    timeout?: number;
+}
+
+const baseExecutor: RequestExecutor<MyCustomOptions> = {
+    async request<T>(config: RequestConfig, options?: MyCustomOptions): Promise<T> {
+        const response = await fetch(config.url, {
+            method: config.method,
+            headers: config.headers,
+            body: config.body ? JSON.stringify(config.body) : undefined,
+            signal: options?.timeout
+                ? AbortSignal.timeout(options.timeout)
+                : undefined,
+        });
+
+        if (!response.ok) {
+            throw new Error(`Request failed: ${response.status}`);
+        }
+
+        return response.json();
+    },
+};
+
+// Оборачиваем executor interceptors
+const executor = withInterceptors(baseExecutor, {
+    onRequest: [
+        (config) => ({
+            ...config,
+            headers: {
+                ...config.headers,
+                Authorization: 'Bearer token',
+            },
+        }),
+    ],
+    onError: [
+        (error) => {
+            console.error(error);
+            throw error;
+        },
+    ],
+});
+
+const service = new SimpleService(executor);
+await service.getCallWithoutParametersAndResponse({ timeout: 5000 });
+```
+
 ### Стратегия сортировки аргументов функций `--sortByRequired`
 По умолчанию генератор OpenAPI сортирует параметры сервисных функций согласно упрощенной схеме. Если вам нужна более строгая опция сортировки, используйте флаг `--sortByRequired`. Упрощенная опция сортировки похожа на ту, что использовалась в версии 0.2.3 генератора OpenAPI. Этот флаг позволяет обновиться до новой версии генератора, если вы "застряли" на версии 0.2.3.
 

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

@@ -1,3 +1,4 @@
+import { OptionValues } from 'commander';
 /**
  * Проверяет конфигурационный файл на корректность и актуальность.
  * Если обнаружены проблемы, предлагает действия для их исправления.
@@ -8,5 +9,5 @@
  * @example
  * await checkConfig('./openapi-config.json');
  */
-export declare function checkConfig(configPath: string): Promise<void>;
+export declare function checkConfig(options: OptionValues): Promise<void>;
 //# sourceMappingURL=checkConfig.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"checkConfig.d.ts","sourceRoot":"","sources":["../../../src/cli/checkAndUpdateConfig/checkConfig.ts"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoCnE"}
+{"version":3,"file":"checkConfig.d.ts","sourceRoot":"","sources":["../../../src/cli/checkAndUpdateConfig/checkConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAUzC;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA4CtE"}