@topvisor/ui 1.0.42-popupPosition.0 → 1.1.0-addativeialog.0

package/types/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/types/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/types/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/types/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/types/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/types/api/api/types/client/request.d.ts

@@ -0,0 +1,85 @@
+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;
+            /**
+             * Признак загрузки
+             */
+            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;
+            /**
+             * Выполнить обращение к методу 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>;
+        }
+        /**
+         * Объект с запросом к методу 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/types/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/types/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;
+            /**
+             * Фильтр по полю
+             */
+            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/types/api/api/types/index.d.ts

@@ -0,0 +1,12 @@
+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 './schema';
+export * from './tv';
+export * from './utils';

package/types/api/api/types/schema.d.ts

@@ -0,0 +1,50 @@
+declare global {
+    /**
+     * Утилиты работы со схемами расширения спецификации OpenAPI для работы с селектором
+     *
+     * @see Api.Ext
+     */
+    namespace Api {
+        /**
+         * Тип операции метода API
+         */
+        type Oper<Paths extends Api.PathsAbstract, Path extends Api.Path<Paths>> = Path extends `/${infer P extends Api.Ext.Schemas['Oper']}/${string}` ? P : never;
+        /**
+         * Модель данных метода
+         *
+         * Для метода без модели вернет `null`
+         */
+        type Model<Paths extends Api.PathsAbstract, Path extends Api.Path<Paths>> = Paths[Path]['post']['responses'][200]['content'] extends {
+            model: infer Model extends Api.Ext.Schemas['Model'];
+        } ? Model : never;
+        type ModelFields<Model extends Api.Ext.Schemas['Model']> = readonly Api.Field.Name<Model>[];
+        /**
+         * Результат метода API, выполненного успешно
+         */
+        type ResponseSuccess<Result, Oper extends Api.Ext.Schemas['Oper']> = {
+            result: Result;
+            /**
+             * Информация о нативных типах данных в результате
+             *
+             * Возвращается при работе с БД
+             */
+            meta?: any[];
+            /**
+             * Списка ошибок в успешных запросах быть не может
+             */
+            errors: undefined;
+            response?: globalThis.Response;
+        } & Omit<Api.Ext.Schemas['ResponseSuccess'], 'result' | 'errors'> & ('get' extends Oper ? Api.Ext.Schemas['Pagination'] : {});
+        /**
+         * Результат метода API с ошибкой
+         */
+        type ResponseError<Result> = {
+            /**
+             * При ошибках результат всегда null
+             */
+            result: null | Result;
+            response?: globalThis.Response;
+        } & Omit<Api.Ext.Schemas['ResponseError'], 'result'>;
+    }
+}
+export {};

package/types/api/api/types/tv.d.ts

@@ -0,0 +1,59 @@
+import { components as ModelsComponents } from 'topvisor-openapi/src/ts/Models';
+import type * as SchemaImported from 'topvisor-openapi/src/ts/Topvisor';
+declare global {
+    namespace Api {
+        /**
+         * Схема API OpenAPI TV
+         *
+         * Также содержит утилиты, которые работают с определяемой схемой и расширением селектора
+         *
+         * Для определения другого API с расширением селектора необходимо определить такой же namespace с нужными `SchemaImported` и `ModelsComponents`
+         */
+        namespace TV {
+            namespace Schema {
+                type paths = SchemaImported.paths;
+                type operations = SchemaImported.operations;
+                type components = SchemaImported.components;
+                type webhooks = SchemaImported.webhooks;
+                type $defs = SchemaImported.$defs;
+            }
+            type Paths = Api.TV.Schema.paths;
+            type Path<Path extends Api.Path<Paths> = Api.Path<Paths>> = Path;
+            /**
+             * Все схемы моделей данных API
+             */
+            type Models = ModelsComponents['schemas'];
+            /**
+             * Параметр списка полей `fields` конкретного метода API
+             */
+            type Fields<Path extends Api.Path<Paths>> = Api.ParamsFields<Api.ClientRequestContext<Paths, Path, true>>;
+            /**
+             * Модель данных конкретного метода API
+             */
+            type Model<Path extends Api.Path<Paths>> = Api.Model<Paths, Path>;
+            /**
+             * Объект запроса к конкретному методу API
+             *
+             * Дженерик Fields в чистом TypeScript не будет работать, так как используется tuple, работает при указании значения в самом js
+             *
+             * @see https://github.com/microsoft/TypeScript/pull/62170
+             *
+             * @remarks Не использовать, тип запроса API должен определяться `client.gen()`, указывать ему тип вручную не рекомендуется
+             */
+            type Request<Path extends Api.Path<Paths>, Fields extends Api.ParamsFields<RequestContext> | undefined = undefined, RequestContext extends Api.ClientRequestContext<Paths, Path, true> = Api.ClientRequestContext<Paths, Path, true>> = Api.ClientRequest<RequestContext, Fields>;
+            /**
+             * Параметры запроса к конкретному методу API
+             */
+            type Params<Path extends Api.Path<Paths>, Fields extends Api.ParamsFields<RequestContext> | undefined = undefined, RequestContext extends Api.ClientRequestContext<Paths, Path, true> = Api.ClientRequestContext<Paths, Path, true>> = Api.Params<RequestContext, Fields>;
+            /**
+             * Результат конкретного метода API
+             */
+            type ResponseSuccess<Path extends Api.Path<Paths>, Fields extends Api.ParamsFields<RequestContext> | undefined = undefined, FetchStyle extends RequestContext['ParamsFetchStyle'] | null = null, RequestContext extends Api.ClientRequestContext<Paths, Path, true> = Api.ClientRequestContext<Paths, Path, true>, Result extends Api.Result<RequestContext, Fields, FetchStyle> = Api.Result<RequestContext, Fields, FetchStyle>> = Api.ResponseSuccess<Result, RequestContext['Oper']>;
+            /**
+             * Результат `res.result` конкретного метода API
+             */
+            type Result<Path extends Api.Path<Paths>, Fields extends Api.ParamsFields<RequestContext> | undefined = undefined, FetchStyle extends RequestContext['ParamsFetchStyle'] | null = null, RequestContext extends Api.ClientRequestContext<Paths, Path, true> = Api.ClientRequestContext<Paths, Path, true>> = Api.Result<RequestContext, Fields, FetchStyle>;
+        }
+    }
+}
+export {};

package/types/api/api/types/utils.d.ts

@@ -0,0 +1,51 @@
+declare global {
+    /**
+     * Общие утилиты
+     */
+    namespace Api {
+        /**
+         * Интерфейс `paths` в схеме openAPI
+         *
+         * Общий интерфейс для разных API
+         *
+         * В данной реализации строго не типизирован
+         *
+         * @see https://learn.openapis.org/specification/structure.html
+         * @see https://spec.openapis.org/oas/v3.1.0#paths-object
+         */
+        type PathsAbstract = Record<string, any>;
+        type PathAbstract = `/${string}` | '';
+        /**
+         * Путь метода API
+         *
+         * Определяет возможные значения пути метода API
+         *
+         * @template T Интерфейс `paths` в схеме openAPI
+         *
+         * @see Api.PathsAbstract
+         */
+        type Path<T extends Api.PathsAbstract> = Extract<keyof T, string>;
+        /**
+         * Создает новый тип на основе T с заменой типа свойства K на NewType, только если ключ K присутствует в T.
+         *
+         * Если ключа нет — возвращается пустой объект.
+         *
+         * Используется для расширения простых типов такими же, но с дженериками
+         */
+        type PickAndRetype<T extends object, K extends PropertyKey, NewType> = K extends keyof T ? undefined extends T[K] ? {
+            [P in K]?: NewType;
+        } : {
+            [P in K]: NewType;
+        } : {};
+        type PropIfExists<T, K extends PropertyKey> = K extends keyof T ? T[K] : never;
+        /**
+         * Сужение возможных значений массива
+         */
+        type ArrowNarrow<T extends readonly any[], FieldsNarrow extends readonly any[]> = Extract<T[number], FieldsNarrow[number]>[] & T;
+        /**
+         * Утилита для условной установки типа по входным условиям
+         */
+        type IfAllTrue<T extends boolean[], Then, Else = never> = false extends T[number] ? Else : Then;
+    }
+}
+export {};

package/types/api/api/utils/common.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Сгенерировать объект ответа в формате расширения OpenAPI
+ *
+ * @see Api.Ext
+ */
+export declare const genExtRes: (result: any, errors?: Api.Ext.Schemas["ResponseError"]["errors"], response?: Response) => Api.Response<any>;
+/**
+ * Это публичное API, к которому открыт доступ по прямой ссылке через GET
+ *
+ * Используется для кеширования и генерации файлов через API
+ */
+export declare const isPublicAPI: (path: Api.PathAbstract) => boolean;
+/**
+ * Сгенерировать baseUrl на основе текущего домена
+ */
+export declare const getBaseDomainUrl: (useMainDomain?: boolean, input?: string) => string;

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

@@ -0,0 +1,8 @@
+/**
+ * Сгенерировать объект API фильтра
+ */
+export declare const genFieldFilter: <Model extends Api.Ext.Schemas["Model"], FieldName extends Api.Field.Name<Model> = Api.Field.Name<Model>>(name: FieldName, operator: Api.Field.Filter<Model, FieldName>["operator"], values: Api.Field.Filter<Model, FieldName>["values"]) => Api.Field.Filter<Model, FieldName>;
+/**
+ * Сгенерировать объект сортировки
+ */
+export declare const genFieldOrder: <Model extends Api.Ext.Schemas["Model"], FieldName extends Api.Field.Name<Model> = Api.Field.Name<Model>>(name: FieldName, direction: Api.Field.Order<Model, FieldName>["direction"], orderValues?: Api.Field.Order<Model, FieldName>["orderValues"], operator?: Api.Field.Order<Model, FieldName>["operator"], values?: Api.Field.Order<Model, FieldName>["values"]) => Api.Field.Order<Model, FieldName>;