@topvisor/ui 1.1.0 → 1.3.0

package/src/api/api/index.d.ts

@@ -0,0 +1,12 @@
+import { Client } from './client/client';
+import { postInWindow, dataToForm } from './utils/lazy';
+export * from './utils/field';
+export * from './utils/common';
+export declare const postInWindow: postInWindow;
+export declare const dataToForm: dataToForm;
+/**
+ * Создать API клиент
+ *
+ * @see Api.Ext.UseExt
+ */
+export declare const createClient: <paths extends Api.PathsAbstract, UseExt extends Api.Ext.UseExt>(clientOptions: Partial<Api.ClientOptions> | undefined, useExt: UseExt) => Client<paths, UseExt>;

package/src/api/api/mocker/index.d.ts

@@ -0,0 +1,9 @@
+export declare const genMockResponse: (options: Api.Mocker.Options<any, any>, fields?: readonly string[], params?: Api.Mocker.Params) => Promise<{
+    result: any;
+    errors: undefined;
+    nextOffset: number | undefined;
+    total: number | undefined;
+}>;
+export declare const genMockResult: <Options extends Api.Mocker.Options<any, any>>(options: Options, fields?: readonly string[], params?: Api.Mocker.Params) => Api.Mocker.ToMockResult<Options["result"]>;
+export declare const genMockItem: <T extends Api.Mocker.Item>(genItem: T, n: number, seed: number, fields?: readonly string[]) => Api.Mocker.ToMockItem<T>;
+export declare const genMockValue: <T extends Api.Mocker.Value>(genValue: T, n?: number) => Api.Mocker.ToMockValue<T>;

package/src/api/api/tests/types.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/src/api/api/types/api.d.ts

@@ -0,0 +1,144 @@
+declare global {
+    /**
+     * Типы, используемые Api клиентом для работы со схемой расширения
+     *
+     * В схеме указываться только `POST` запросы в формате `application/json`, мотивация: схема не должна быть перегруженной
+     *
+     * При этом API обязано поддерживать те же запросы:
+     *
+     * - с HTTP методом GET: для поддержки кеширования
+     * - в формате `multipart/form-data`: для поддержки работы с файлами
+     *
+     * @see Api.Ext
+     */
+    namespace Api {
+        /**
+         * Параметры запроса метода API
+         *
+         * @template Path Путь метода API
+         */
+        type Params<RequestContext extends Api.ClientRequestContext<any, any, any>, FieldsNarrow extends Api.ParamsFields<RequestContext> | undefined = undefined, Model extends RequestContext['Model'] = RequestContext['Model'], ParamsOriginal extends Api.ParamsOriginal<RequestContext> = Api.ParamsOriginal<RequestContext>> = Omit<ParamsOriginal, 'fields' | 'filters' | 'orders' | 'fetch_style'> & Api.PickAndRetype<ParamsOriginal, 'fields', FieldsNarrow extends Api.Ext.Schemas['Fields'] ? Api.ArrowNarrow<Api.ParamsFields<RequestContext>, FieldsNarrow> : Api.ParamsFields<RequestContext>> & Api.PickAndRetype<ParamsOriginal, 'filters', [Model] extends [never] ? never : Api.Field.Filter<Model>[]> & Api.PickAndRetype<ParamsOriginal, 'orders', [Model] extends [never] ? never : Api.Field.Order<Model>[]>;
+        /**
+         * Получить параметр списка полей с учетом дженериков модели
+         *
+         * Если в схеме не указан конкретный тип `fields`, он будет заменен типом из модели
+         */
+        type ParamsFields<RequestContext extends Api.ClientRequestContext<any, any, any>, ParamsOriginalFields extends Api.ParamsOriginalFields<RequestContext> = Api.ParamsOriginalFields<RequestContext>> = [RequestContext['Model']] extends [never] ? ParamsOriginalFields : ParamsOriginalFields extends Api.Ext.Schemas['Fields'] ? Api.ModelFields<RequestContext['Model']> : ParamsOriginalFields;
+        /**
+         * Параметры запроса метода API, классический OpenAPI без дженериков
+         *
+         * @template Path Путь метода API
+         * @template T Интерфейс `paths` в схеме openAPI
+         *
+         * @see PathsAbstract
+         */
+        type ParamsOriginal<RequestContext extends Api.ClientRequestContext<any, any, any>> = RequestContext['Schema']['post'] extends {
+            requestBody: {
+                content: {
+                    'application/json': infer P extends Record<string, any>;
+                };
+            };
+        } ? P : Record<string, any>;
+        type ParamsOriginalByPath<Paths extends Api.PathsAbstract, Path extends Api.Path<Paths>> = Paths[Path]['post'] extends {
+            requestBody: {
+                content: {
+                    'application/json': infer P extends Record<string, any>;
+                };
+            };
+        } ? P : Record<string, any>;
+        /**
+         * Получить параметр списка полей без учета дженериков модели и преобразовать его в базовый тип `fields`
+         */
+        type ParamsOriginalFields<RequestContext extends Api.ClientRequestContext<any, any, any>> = Api.ParamsOriginal<RequestContext> extends {
+            fields?: infer Fields extends any[];
+        } ? unknown[] extends Fields ? Api.Ext.Schemas['Fields'] : Fields : never;
+        /**
+         * Тип ответа метода API с расширением дженериков для TV Open API
+         *
+         * Расширение классического `ResponseOriginal`
+         *
+         * @template RequestContext Контекст запроса
+         * @template Fields Имена полей для выборки, так как это массив, подстановка типа тут работать не будет, подстановка реализуется в js утилите
+         * @template FetchStyle Способ получения данных, влияет на тип получения результата, по умолчанию `null` - определяется автоматически
+         *
+         * @see Api.Ext.FetchStyle
+         * @see `ResponseOriginal`
+         */
+        type Response<RequestContext extends Api.ClientRequestContext<any, any, any>, Fields extends Api.ParamsFields<RequestContext> | undefined = undefined, FetchStyle extends RequestContext['ParamsFetchStyle'] | null = null, Result extends Api.Result<RequestContext, Fields, FetchStyle> = Api.Result<RequestContext, Fields, FetchStyle>> = Api.ResponseSuccess<Result, RequestContext['Oper']> | Api.ResponseError<Result>;
+        /**
+         * Тип ответа метода API с произвольной типизацией
+         *
+         * Для случаев, когда тип не описан в Open API
+         *
+         * Расширение классического `ResponseOriginal`
+         *
+         * @see ResponseOriginal
+         */
+        type ResponseCustom<Result = any> = Api.ResponseSuccess<Result, any> | Api.ResponseError<Result>;
+        /**
+         * Тип ответа метода API, классический OpenAPI без дженериков
+         *
+         * @template Path Путь метода API
+         * @template T Интерфейс `paths` в схеме openAPI
+         *
+         * @see PathsAbstract
+         */
+        type ResponseOriginal<RequestContext extends Api.ClientRequestContext<any, any, any>> = RequestContext['Schema']['post']['responses'][200]['content'] extends {
+            'application/json': infer R extends Record<string, any>;
+        } ? R : never;
+        /**
+         * Тип `result` в ответе метода API
+         *
+         * Для методов API без модели и fetchStyle
+         *
+         * @template Path Путь метода API
+         * @template T Интерфейс `paths` в схеме openAPI
+         *
+         * @see `ResponseOriginal`
+         * @see PathsAbstract
+         */
+        type ResponseOriginalResult<RequestContext extends Api.ClientRequestContext<any, any, any>> = Exclude<Api.ResponseOriginal<RequestContext>, Api.Ext.Schemas['ResponseError']> extends {
+            result?: infer R;
+        } ? R : never;
+        /**
+         * Результат в ответе метода API
+         *
+         * Не путайте с ответом API `Response`, который помимо результата содержит дополнительную информацию о выполнении метода
+         *
+         * @see Api.Response
+         */
+        type Result<RequestContext extends Api.ClientRequestContext<any, any, any>, Fields extends Api.ParamsFields<RequestContext> | undefined = undefined, FetchStyle extends RequestContext['ParamsFetchStyle'] | null = null, Model extends RequestContext['Model'] = RequestContext['Model'], ResponseOriginalResult extends Api.ResponseOriginalResult<RequestContext> = Api.ResponseOriginalResult<RequestContext>> = [Model] extends [never] ? ResponseOriginalResult : null extends FetchStyle ? RequestContext['Oper'] extends 'get' ? ResultModel<Fields, 'fetchAll', Model> : ResponseOriginalResult : ResultModel<Fields, NonNullable<FetchStyle>, Model>;
+        /**
+         * Результат в ответе метода API для модели
+         *
+         * @see Api.Result
+         */
+        type ResultModel<Fields extends Api.ModelFields<Model> | undefined, FetchStyle extends Api.Ext.Schemas['FetchStyle'], Model extends Api.Ext.Schemas['Model']> = Fields extends Api.ModelFields<Model> ? ResultByModelFetchStyle<Fields, Model>[FetchStyle] : never;
+        /**
+         * Преобразование модели в зависимости от `fetchStyle`
+         */
+        type ResultByModelFetchStyle<Fields extends Api.ModelFields<Model>, Model extends Api.Ext.Schemas['Model']> = {
+            fetchAll: ModelSelected<Fields, Model>[];
+            fetchAllNum: number[][];
+            fetchAllColumn: Fields[0] extends keyof Model ? Model[Fields[0]][] : never;
+            fetch: ModelSelected<Fields, Model>;
+            fetchColumn: Fields[0] extends keyof Model ? Model[Fields[0]] : never;
+            fetchGroup: Record<string, ModelSelected<Fields, Model>[]>;
+            fetchGroupColumn: Fields[0] extends keyof Model ? Record<string, Model[Fields[0]][]> : never;
+            fetchUnique: Record<string, ModelSelected<Fields, Model>>;
+            fetchUniqueNum: Fields extends [] ? never : Record<string, SelectedModelNum<Fields, Model>>;
+            fetchUniqueColumn: Fields[0] extends keyof Model ? Record<string, Model[Fields[0]]> : never;
+        };
+        /**
+         * Модель только с нужными полями
+         */
+        type ModelSelected<Fields extends Api.ModelFields<Model>, Model extends Api.Ext.Schemas['Model']> = Fields extends [] ? never : Omit<Model, Exclude<keyof Model, Fields[number]>>;
+        /**
+         * Модель только с нужными полями без имен
+         */
+        type SelectedModelNum<Fields extends Api.ModelFields<Model>, Model extends Api.Ext.Schemas['Model']> = Fields extends [] ? never : {
+            [K in keyof Fields]: Fields[K] extends keyof Model ? Model[Fields[K]] : never;
+        };
+    }
+}
+export {};

package/src/api/api/types/client/client.d.ts

@@ -0,0 +1,8 @@
+import { Client as ClientClass } from '../../client/client';
+declare global {
+    namespace Api {
+        interface Client<paths extends Api.PathsAbstract, UseExt extends Api.Ext.UseExt> extends ClientClass<paths, UseExt> {
+        }
+    }
+}
+export {};

package/src/api/api/types/client/middleware.d.ts

@@ -0,0 +1,65 @@
+declare global {
+    namespace Api {
+        type Middleware = {
+            onRequest: MiddlewareOnRequest;
+            onResponse?: MiddlewareOnResponse;
+            onError?: MiddlewareOnError;
+        } | {
+            onRequest?: MiddlewareOnRequest;
+            onResponse: MiddlewareOnResponse;
+            onError?: MiddlewareOnError;
+        } | {
+            onRequest?: MiddlewareOnRequest;
+            onResponse?: MiddlewareOnResponse;
+            onError: MiddlewareOnError;
+        };
+        type MiddlewareOnRequest = (ctx: MiddlewareCallbackParams) => void | globalThis.Request | globalThis.Response | undefined | Promise<globalThis.Request | globalThis.Response | undefined | void>;
+        type MiddlewareOnResponse = (ctx: MiddlewareCallbackParams & {
+            response: globalThis.Response;
+        }) => void | globalThis.Response | undefined | Promise<globalThis.Response | undefined | void>;
+        type MiddlewareOnError = (ctx: MiddlewareCallbackParams & {
+            error: unknown;
+        }) => void | globalThis.Response | Error | Promise<void | globalThis.Response | Error>;
+        type MiddlewareCallbackParams = {
+            readonly useExt: Api.Ext.UseExt;
+            readonly requestOptions: Api.ClientRequestOptions;
+            /**
+             * Параметры запроса
+             *
+             * Для модификации параметров запроса используйте настройку клиента: `onPrepareData`
+             *
+             * @see Api.ClientOptions.onPrepareData
+             */
+            readonly data: Readonly<Record<string, any>>;
+            /**
+             * Дополнительная информация о запросе
+             *
+             * Только для middleware
+             */
+            middlewareData: Record<string, any>;
+            /**
+             * Основные параметры клиента API
+             */
+            readonly options: Api.BaseOptions;
+            /**
+             * Путь схемы OpenAPI
+             */
+            readonly schemaPath: Api.PathAbstract;
+            /**
+             * Уникальный идентификатор этого запроса
+             */
+            readonly id: string;
+            /**
+             * Объект запроса, который будет использоваться в `fetch()`
+             */
+            request: globalThis.Request;
+        };
+        /**
+         * Ошибка при разборе результата API
+         */
+        type FormatError = (SyntaxError | TypeError) & {
+            responseText?: string;
+        };
+    }
+}
+export {};

package/src/api/api/types/client/options.d.ts

@@ -0,0 +1,60 @@
+declare global {
+    namespace Api {
+        /**
+         * Опции клиента API
+         *
+         * Опции применяются для всех запросов
+         */
+        interface ClientOptions extends BaseOptions, RequestInit {
+            /**
+             * Расширенные настройки выполнения запроса по умолчанию для всех запросов API клиента
+             */
+            requestOptions: Partial<Api.ClientRequestOptions>;
+            /**
+             * Хук, для модификации параметров запроса
+             *
+             * Данные `data` безопасно меняются по ссылке
+             *
+             * Используется перед созданием объекта запроса `Request`
+             *
+             * Является более оптимальным решением, чем пересоздание запроса через middleware `onRequest()`
+             */
+            onPrepareData?: (data: Record<string, any>, options: Omit<Api.MiddlewareCallbackParams, 'request'>) => void;
+            /**
+             * Выводить ли информацию о перехваченных ошибках API с помощью `console`
+             *
+             * Только при использовании `useExt`
+             *
+             * @see console
+             */
+            useApiConsole?: boolean;
+        }
+        type BaseOptions = {
+            /**
+             * Базовый URL для всех API-запросов
+             */
+            baseUrl?: string;
+            /**
+             * Глобальный сериализатор query-параметров
+             */
+            querySerializer: (input: Record<string, any>) => Promise<string> | string;
+            /**
+             * Глобальный сериализатор тела запроса
+             */
+            bodySerializer: (input: Record<string, any>) => string;
+            /**
+             * Пользовательский реализация `Request`
+             *
+             * @see Request
+             */
+            Request: typeof Request;
+            /**
+             * Пользовательская реализация `fetch`
+             *
+             * @see fetch
+             */
+            fetch: (input: RequestInfo, init?: RequestInit) => Promise<globalThis.Response>;
+        };
+    }
+}
+export {};

package/src/api/api/types/client/request-context.d.ts

@@ -0,0 +1,35 @@
+declare global {
+    namespace Api {
+        /**
+         * Контекст выполнения запросов
+         */
+        interface ClientRequestContext<Paths extends Api.PathsAbstract, Path extends Api.Path<Paths>, UseExt extends Api.Ext.UseExt> {
+            /**
+             * @see Api.PathsAbstract
+             */
+            Paths: Paths;
+            /**
+             * @see Api.Path
+             */
+            Path: Path;
+            /**
+             * @see Api.Ext.UseExt
+             */
+            UseExt: UseExt;
+            /**
+             * Схема API метода
+             *
+             * @see Api.PathsAbstract
+             * @see https://learn.openapis.org/specification/paths.html#the-path-item-object
+             * @see https://spec.openapis.org/oas/v3.1.0#path-item-object
+             */
+            Schema: Paths[Path];
+            Oper: UseExt extends true ? Api.Oper<Paths, Path> : never;
+            Model: Api.Model<Paths, Path>;
+            ParamsFetchStyle: [Api.Model<Paths, Path>] extends [never] ? never : Api.ParamsOriginalByPath<Paths, Path> extends {
+                fetch_style?: any;
+            } ? Api.Ext.Schemas['FetchStyle'] : never;
+        }
+    }
+}
+export {};

package/src/api/api/types/client/request-options.d.ts

@@ -0,0 +1,73 @@
+declare global {
+    namespace Api {
+        /**
+         * Расширенные настройки выполнения запроса
+         */
+        interface ClientRequestOptions {
+            /**
+             * Элемент, который получит статус загрузки
+             *
+             * Для использования в хуке `onLoading()`
+             */
+            loadingEl: HTMLElement;
+            /**
+             * Отображать ли индикатор загрузки
+             *
+             * Для использования в хуке `onLoading()`
+             */
+            loadingShowSpinner: boolean;
+            /**
+             * Событие смены статуса загрузки
+             */
+            onLoading?: (isLoading: boolean, ctx: Api.MiddlewareCallbackParams) => void | Promise<void>;
+            /**
+             * Событие, которое сработает при получении результата API
+             *
+             * Не путать с результатами `fetch()`
+             *
+             * Только при использовании `useExt`
+             */
+            onApiLoaded?: (res: Api.Response<any>, ctx: Api.MiddlewareCallbackParams) => void | Promise<void>;
+            /**
+             * Событие, которое сработает при получении ошибки API в `res.errors`
+             *
+             * Не путать с ошибками `fetch()`
+             *
+             * Только при использовании `useExt`
+             *
+             * При переопределении на уровне запроса API, вы можете переиспользовать ранее определенное событие на уровне API клиента:
+             * ```
+             * onApiError = (res, ctx, prevOnError) => prevOnApiError?.(res, ctx);
+             * ```
+             *
+             * @see createClient
+             */
+            onApiError?: (res: Api.Response<any>, ctx: Api.MiddlewareCallbackParams & {
+                formatError?: FormatError;
+            }, prevOnApiError?: this['onApiError']) => void | Promise<void>;
+            /**
+             * Событие, которое сработает при получении сообщения API в `res.messages`
+             *
+             * Только при использовании `useExt`
+             */
+            onApiMessage?: (res: Api.Response<any>, ctx: Api.MiddlewareCallbackParams) => void | Promise<void>;
+            /**
+             * Отклонить предыдущий запрос, если запрошен новый с таким же значением `checkFingerprint`
+             *
+             * В этом случае запрос вернет результат с ошибкой соединения с кодом `0`
+             */
+            checkFingerprint?: string;
+            /**
+             * Метод HTTP запроса
+             *
+             * @see https://developer.mozilla.org/ru/docs/Web/HTTP/Reference/Methods
+             */
+            method: 'GET' | 'POST';
+            /**
+             * Ожидаемый тип контента в ответе
+             */
+            accept: 'application/json' | 'text/csv';
+        }
+    }
+}
+export {};

package/src/api/api/types/client/request.d.ts

@@ -0,0 +1,91 @@
+declare global {
+    namespace Api {
+        /**
+         * Объект с запросом к конкретному методу API
+         */
+        interface ClientRequest<RequestContext extends Api.ClientRequestContext<any, any, any>, FieldsNarrow extends Api.ParamsFields<RequestContext> | undefined = undefined, Params extends Api.Params<RequestContext> = Api.Params<RequestContext>, ParamsFieldsNarrowed extends Api.PropIfExists<Params, 'fields'> = Api.PropIfExists<Params, 'fields'>> {
+            /**
+             * Имя метода
+             */
+            readonly path: Api.PathAbstract;
+            /**
+             * Url для обращения к методу API
+             *
+             * Не включает параметры запроса
+             */
+            readonly url: string;
+            /**
+             * Параметры метода API
+             */
+            params: Omit<Params, 'fields'> & (Params extends {
+                fields: any;
+            } ? Readonly<Pick<Params, 'fields'>> : {});
+            /**
+             *  Опции запроса
+             */
+            options: Api.ClientRequestOptions;
+            mockerOptions?: Api.Mocker.Options<Api.Mocker.Result, Params>;
+            /**
+             * Признак загрузки
+             */
+            inLoading: boolean;
+            /**
+             * Получить флаг загрузки
+             */
+            getInLoading(): boolean;
+            /**
+             * Переназначить параметры запроса
+             *
+             * Полностью заменит предыдущее значение параметров
+             */
+            setParams(params: Omit<Params, 'fields' | 'fetch_style'>): this;
+            /**
+             * Изменить параметры запроса
+             */
+            changeParams(params: Partial<Omit<Params, 'fields' | 'fetch_style'>>): this;
+            /**
+             * Установить расширенные настройки запроса
+             */
+            setOptions(options: Partial<Api.ClientRequestOptions>): this;
+            /**
+             * Установить генератор данных вместо реальных запросов к серверу
+             */
+            setMocker<MockerResult extends Api.Mocker.Result>(options?: Api.Mocker.Options<MockerResult, Params>): this;
+            /**
+             * Выполнить обращение к методу API
+             */
+            call<Fields extends ParamsFieldsNarrowed & FieldsNarrow>(fields?: Fields): Promise<RequestContext['UseExt'] extends true ? Api.Response<RequestContext, Fields> : Api.ResponseOriginal<RequestContext>>;
+            /**
+             * Выполнить обращение к методу API с указанием `fetchStyle`
+             */
+            callFetch: <Fields extends ParamsFieldsNarrowed & FieldsNarrow, FetchStyle extends RequestContext['ParamsFetchStyle']>(fetchStyle: FetchStyle, fields?: Fields) => Promise<Api.Response<RequestContext, Fields, FetchStyle>>;
+            /**
+             * Выполнить обращение к методу API в новом окне
+             *
+             * Примеры использования:
+             * - скачивание файлов
+             * - печать документов
+             */
+            callInNewWindow(fields?: ParamsFieldsNarrowed & FieldsNarrow): void;
+            /**
+             * Выполнить обращение к методу API в текущем окне
+             *
+             * Примеры использования:
+             * - переход на станицу интеграции, OAuth
+             * - открытие формы оплаты
+             */
+            callInSelfWindow(fields?: ParamsFieldsNarrowed & FieldsNarrow): void;
+            /** Генерация параметров запроса */
+            genData<FetchStyle extends RequestContext['ParamsFetchStyle']>(fields?: FieldsNarrow, fetchStyle?: FetchStyle): Record<string, any>;
+            exec(fields?: FieldsNarrow, fetchStyle?: RequestContext['ParamsFetchStyle']): Promise<any>;
+        }
+        /**
+         * Объект с запросом к методу API, не описанному в OpenAPI
+         */
+        interface ClientRequestCustom<useExt extends Api.Ext.UseExt, Params extends Record<string, any>, Result> extends ClientRequest<Api.ClientRequestContext<any, any, useExt>, any[], Params> {
+            params: Params;
+            call(fields?: any): Promise<useExt extends true ? Api.ResponseCustom<Result> : Result>;
+        }
+    }
+}
+export {};

package/src/api/api/types/ext.d.ts

@@ -0,0 +1,51 @@
+import { components as FetchStyleComponents } from 'topvisor-openapi/src/ts/FetchStyle';
+import { components as FieldDirectionComponents } from 'topvisor-openapi/src/ts/FieldDirection';
+import { components as FieldFilterComponents } from 'topvisor-openapi/src/ts/FieldFilter';
+import { components as FieldOperatorComponents } from 'topvisor-openapi/src/ts/FieldOperator';
+import { components as FieldOrderComponents } from 'topvisor-openapi/src/ts/FieldOrder';
+import { components as ResponseErrorComponents } from 'topvisor-openapi/src/ts/ResponseError';
+import { components as ResponseSuccessComponents } from 'topvisor-openapi/src/ts/ResponseSuccess';
+import { components as PaginationComponents } from 'topvisor-openapi/src/ts/Pagination';
+declare global {
+    namespace Api {
+        /**
+         * Схемы расширения спецификации OpenAPI для работы с селектором
+         *
+         * Эти схемы реализуются с помощью Api клиента и дженериков
+         *
+         * В данном namespace определяются только базовые схемы без дженериков
+         */
+        namespace Ext {
+            /**
+             * Использовать расширение спецификации OpenAPI с селектором
+             */
+            type UseExt = boolean;
+            /**
+             * Базовые структуры расширения селектора для API без дженериков
+             */
+            type Schemas = {
+                /**
+                 * Операция метода API
+                 *
+                 * Определяет возможные операции метода API
+                 */
+                Oper: 'get' | 'edit' | 'add' | 'del';
+            } & {
+                /**
+                 * Базовый тип для всех моделей
+                 */
+                Model: Record<string, any>;
+            } & {
+                /**
+                 * Базовый тип списка полей
+                 *
+                 * @todo Реализовать тип объектов
+                 */
+                Fields: readonly string[];
+            } & {
+                FetchStyle: Extract<FetchStyleComponents['schemas']['FetchStyle'], keyof Api.ResultByModelFetchStyle<any, any>>;
+            } & FieldDirectionComponents['schemas'] & FieldFilterComponents['schemas'] & FieldOperatorComponents['schemas'] & FieldOrderComponents['schemas'] & ResponseErrorComponents['schemas'] & ResponseSuccessComponents['schemas'] & PaginationComponents['schemas'];
+        }
+    }
+}
+export {};

package/src/api/api/types/field.d.ts

@@ -0,0 +1,33 @@
+declare global {
+    namespace Api {
+        /**
+         * Поле - это составляющая часть объектов, которые характеризуются типом, называемым моделью
+         *
+         * Модель данных обеспечивает доступ и управление к коллекциям
+         *
+         * Не все API работают с моделью данных
+         */
+        namespace Field {
+            /**
+             * Имя поля
+             */
+            type Name<Model extends Api.Ext.Schemas['Model']> = keyof Model extends string ? keyof Model : string;
+            /**
+             * Фильтр по полю
+             */
+            type Filter<Model extends Api.Ext.Schemas['Model'], FieldName extends Api.Field.Name<Model> = Api.Field.Name<Model>> = {
+                name: FieldName;
+                values: Model[FieldName][];
+            } & Omit<Api.Ext.Schemas['FieldFilter'], 'name'>;
+            /**
+             * Сортировка по полю
+             */
+            type Order<Model extends Api.Ext.Schemas['Model'], FieldName extends Api.Field.Name<Model> = Api.Field.Name<Model>> = {
+                name: FieldName;
+                orderValues?: Model[FieldName][];
+                values?: Model[FieldName][];
+            } & Omit<Api.Ext.Schemas['FieldOrder'], 'name' | 'orderValues' | 'values'>;
+        }
+    }
+}
+export {};

package/src/api/api/types/index.d.ts

@@ -0,0 +1,13 @@
+export * from './client/client';
+export * from './client/middleware';
+export * from './client/options';
+export * from './client/request-context';
+export * from './client/request-options';
+export * from './client/request';
+export * from './api';
+export * from './ext';
+export * from './field';
+export * from './mocker';
+export * from './schema';
+export * from './tv';
+export * from './utils';