@dxtmisha/functional 1.15.2 → 1.15.5

package/ai-types.md

@@ -6,46 +6,31 @@ The following is the content of "exports" from package.json:
 {
   ".": {
     "import": "./dist/library.js",
-    "types": "./dist/src/library.d.ts"
+    "types": "./dist/library.d.ts"
   },
   "./flags": {
     "import": "./dist/flags.js",
-    "types": "./dist/src/flags.d.ts"
+    "types": "./dist/flags.d.ts"
   }
 }
 
-// File: src/classes/design/DesignAbstract.d.ts
+export * from '@dxtmisha/functional-basic';
 export declare abstract class DesignAbstract<T extends Record<string, any>, C extends Record<string, any>> {
     constructor(props: T, callback?: ((event: C) => void) | undefined, changed?: string[]);
     make(compelled?: boolean): this;
     makeCallback(compelled?: boolean): void;
 }
-
-// File: src/classes/design/DesignAsyncAbstract.d.ts
-import { DesignAbstract } from './DesignAbstract';
 export declare abstract class DesignAsyncAbstract<T extends Record<string, any>, C extends Record<string, any>> extends DesignAbstract<T, C> {
     make(compelled?: boolean): this;
     makeCallback(compelled?: boolean): Promise<void>;
 }
-
-// File: src/classes/design/DesignChanged.d.ts
 export declare class DesignChanged<T extends Record<string, any>> {
     constructor(props: T, watch?: string[]);
     is(name: string | string[]): boolean;
     isChanged(): boolean;
     update(): void;
 }
-
-// File: src/classes/design/DesignComp.d.ts
-import { DesignComponents } from './DesignComponents';
-import { ConstrComponent, ConstrItem } from '../../types/constructorTypes';
-export declare class DesignComp<COMP extends ConstrComponent, P extends ConstrItem> extends DesignComponents<COMP, P> {
-}
-
-// File: src/classes/design/DesignComponents.d.ts
-import { ComputedRef, VNode } from 'vue';
-import { RawChildren, RawSlots } from '../../types/refTypes';
-import { ConstrComponent, ConstrComponentMod, ConstrItem } from '../../types/constructorTypes';
+export declare class DesignComp<COMP extends ConstrComponent, P extends ConstrItem> extends DesignComponents<COMP, P> {}
 export declare class DesignComponents<COMP extends ConstrComponent, P extends ConstrItem> {
     constructor(components?: COMP, modification?: ConstrComponentMod<P> | undefined);
     is<K extends keyof COMP>(name: K): name is K;
@@ -55,14 +40,7 @@ export declare class DesignComponents<COMP extends ConstrComponent, P extends Co
     renderOne<K extends keyof COMP, PK extends keyof P>(name: K & string, props?: P[PK] & ConstrItem | ConstrItem, children?: RawChildren | RawSlots, index?: PK & string | string): VNode | undefined;
     renderAdd<K extends keyof COMP, PK extends keyof P>(item: any[], name: K & string, props?: P[PK] & ConstrItem | ConstrItem, children?: RawChildren | RawSlots, index?: PK & string | string): this;
 }
-
-// File: src/classes/design/DesignConstructorAbstract.d.ts
-import { ComputedRef, ToRefs, VNode, Ref } from 'vue';
-import { DesignComponents } from './DesignComponents';
-import { ConstrClass, ConstrClasses, ConstrClassObject, ConstrComponent, ConstrEmit, ConstrExpose, ConstrItem, ConstrOptions, ConstrStyles } from '../../types/constructorTypes';
 export declare abstract class DesignConstructorAbstract<E extends Element, COMP extends ConstrComponent, EMITS extends ConstrItem, EXPOSE extends ConstrItem, SLOTS extends ConstrItem, CLASSES extends ConstrClasses, P extends ConstrItem> {
-    protected constructor(name: string, props: Readonly<P>, options?: ConstrOptions<COMP, EMITS, P> | undefined);
-    protected init(): this;
     getName(): string;
     getDesign(): string;
     getSubClass(name: string | string[]): string;
@@ -71,15 +49,7 @@ export declare abstract class DesignConstructorAbstract<E extends Element, COMP
     getAttrs(): ConstrItem;
     expose(): ConstrExpose<E, EXPOSE>;
     render(): () => VNode | (VNode | any)[] | undefined;
-    protected initSlot<K extends keyof SLOTS>(name: K, children?: any[], props?: ConstrItem): VNode | undefined;
-    protected toClass(classes?: ConstrClass): ConstrClassObject;
-    protected toClassName<T extends ConstrItem>(classes?: ConstrItem): T;
 }
-
-// File: src/classes/ref/DatetimeRef.d.ts
-import { ComputedRef, Ref } from 'vue';
-import { Datetime, GeoDate, GeoFirstDay, GeoHours, NumberOrStringOrDate } from '@dxtmisha/functional-basic';
-import { RefOrNormal } from '../../types/refTypes';
 export declare class DatetimeRef {
     constructor(date: RefOrNormal<NumberOrStringOrDate>, type?: RefOrNormal<GeoDate>, code?: RefOrNormal<string>);
     getItem(): Ref<NumberOrStringOrDate>;
@@ -97,23 +67,12 @@ export declare class DatetimeRef {
     locale(type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions): ComputedRef<string>;
     standard(timeZone?: boolean): ComputedRef<string>;
 }
-
-// File: src/classes/ref/EffectScopeGlobal.d.ts
 export declare class EffectScopeGlobal {
     static run<T>(fn: () => T): T | undefined;
 }
-
-// File: src/classes/ref/EventRef.d.ts
-import { RefOrNormal } from '../../types/refTypes';
-import { ElementOrString, ElementOrWindow, EventItem, EventListenerDetail, EventOptions } from '@dxtmisha/functional-basic';
 export declare class EventRef<E extends ElementOrWindow, O extends Event, D extends Record<string, any> = Record<string, any>> extends EventItem<E, O, D> {
     constructor(elementSelector?: RefOrNormal<ElementOrString<E> | undefined>, elementSelectorControl?: RefOrNormal<ElementOrString<HTMLElement>>, type?: string | string[], listener?: EventListenerDetail<O, D>, options?: EventOptions, detail?: D);
 }
-
-// File: src/classes/ref/GeoFlagRef.d.ts
-import { ComputedRef } from 'vue';
-import { GeoFlag, GeoFlagItem, GeoFlagNational } from '@dxtmisha/functional-basic';
-import { RefOrNormal } from '../../types/refTypes';
 export declare class GeoFlagRef {
     constructor(code?: RefOrNormal<string | undefined>);
     getCode(): string;
@@ -125,11 +84,6 @@ export declare class GeoFlagRef {
     getNational(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
     getNationalLanguage(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
 }
-
-// File: src/classes/ref/GeoIntlRef.d.ts
-import { ComputedRef } from 'vue';
-import { GeoDate, ItemValue, NumberOrString, NumberOrStringOrDate } from '@dxtmisha/functional-basic';
-import { RefOrNormal } from '../../types/refTypes';
 export declare class GeoIntlRef {
     constructor(code?: RefOrNormal<string>);
     display(value?: RefOrNormal<string>, typeOptions?: Intl.DisplayNamesOptions['type'] | Intl.DisplayNamesOptions): ComputedRef<string>;
@@ -155,10 +109,6 @@ export declare class GeoIntlRef {
     time(value: RefOrNormal<NumberOrStringOrDate>): ComputedRef<string>;
     sort<T>(data: RefOrNormal<T[]>, compareFn?: (a: T, b: T) => [string, string]): ComputedRef<T[]>;
 }
-
-// File: src/classes/ref/GeoRef.d.ts
-import { ComputedRef, Ref } from 'vue';
-import { GeoItemFull } from '@dxtmisha/functional-basic';
 export declare class GeoRef {
     static get(): Ref<GeoItemFull>;
     static getCountry(): ComputedRef<string>;
@@ -171,11 +121,6 @@ export declare class GeoRef {
     static set(code: string): void;
     static setValueDefault(code?: string | (() => string)): void;
 }
-
-// File: src/classes/ref/GeoUnitRef.d.ts
-import { ComputedRef, Ref } from 'vue';
-import { GeoUnit, NumberOrString } from '@dxtmisha/functional-basic';
-import { RefOrNormal } from '../../types/refTypes';
 export declare class GeoUnitRef {
     constructor(code?: RefOrNormal<string>);
     getLocation(): ComputedRef<string>;
@@ -192,12 +137,8 @@ export declare class GeoUnitRef {
     liter(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
     celsius(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
     kilometerPerHour(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
+    format(value: RefOrNormal<NumberOrString>, unit: RefOrNormal<string>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
 }
-
-// File: src/classes/ref/ListDataRef.d.ts
-import { RefOrNormal, RefType } from '../../types/refTypes';
-import { ListDataFull, ListDataItem, ListList, ListListInput, ListNames, ListSelectedItem, ListSelectedList } from '../../types/listTypes';
-import { ComputedRef } from 'vue';
 export declare class ListDataRef {
     constructor(list: RefOrNormal<ListListInput | undefined>, focus?: RefType<ListSelectedItem | undefined> | undefined, highlight?: RefType<string | undefined> | undefined, highlightLengthStart?: RefType<number | undefined> | undefined, filterMode?: RefType<boolean | undefined> | undefined, selected?: RefType<ListSelectedList | undefined> | undefined, keyValue?: RefType<string | undefined> | undefined, keyLabel?: RefType<string | undefined> | undefined, lite?: RefType<number | undefined> | undefined, min?: RefOrNormal<number | string | undefined>, max?: RefOrNormal<number | string | undefined>, parent?: string | undefined);
     readonly data: ComputedRef<ListList>;
@@ -235,18 +176,17 @@ export declare class ListDataRef {
     getIndexByStep(index: string, step: number): ListDataItem | undefined;
     getIndexNext(index: string): ListDataItem | undefined;
     getIndexPrev(index: string): ListDataItem | undefined;
-    getItemByIndex(index?: string): { key: number; item: ListDataItem; } | undefined;
+    getItemByIndex(index?: string): {
+        key: number;
+        item: ListDataItem;
+    } | undefined;
     getItemByKey(key: number): ListDataItem | undefined;
     getFirstItemByParent(parent: string | undefined): ListDataItem | undefined;
     getLastItemByParent(parent: string | undefined): ListDataItem | undefined;
     getSubList(item: ListDataItem): ListDataRef;
 }
-
-// File: src/classes/ref/RouterItemRef.d.ts
-import { RouteLocationRaw, Router } from 'vue-router';
-import { ConstrHrefProps } from '../../types/constructorTypes';
 export declare class RouterItemRef {
-    static get(): Router;
+    static get(): _RouterClassic;
     static getLink(name: string, params?: any, query?: any): string | undefined;
     static getHref(name?: string, params?: any, query?: any): ConstrHrefProps;
     static push(to: string | RouteLocationRaw): void;
@@ -254,56 +194,79 @@ export declare class RouterItemRef {
     static setOneTime(router: Router): void;
     static rawToHref(to?: string | RouteLocationRaw): ConstrHrefProps;
 }
-
-// File: src/classes/ref/ScrollbarWidthRef.d.ts
-import { Ref, ComputedRef } from 'vue';
 export declare class ScrollbarWidthRef {
     readonly item: Ref<boolean | undefined, boolean | undefined>;
     readonly width: Ref<number, number>;
     constructor();
     readonly is: ComputedRef<boolean>;
 }
-
-// File: src/composables/ref/useApiAsyncRef.d.ts
-import { ApiInstance, ApiData, ApiDataValidation, ApiErrorStorageList } from '@dxtmisha/functional-basic';
-import { UseApiRef } from './useApiRef';
-import { RefOrNormal, RefType } from '../../types/refTypes';
-import { ApiOptions } from '../../types/apiTypes';
+/**
+ * Asynchronous reactive composable for API requests with built-in SSR support.
+ * Wraps `useApiRef` and immediately calls `initSsr()` to ensure data is pre-fetched on the server side.
+ * Use this composable ONLY if you need the request to be executed on the server side during SSR.
+ * For all other cases, use `useApiRef`.
+ *
+ * @example
+ * ```typescript
+ * import { Schema as S } from '@effect/schema'
+ * import { useApiAsyncRef } from '@dxtmisha/functional'
+ *
+ * const userSchema = S.Struct({ id: S.Number, name: S.String })
+ *
+ * // Data will be pre-fetched on the server during SSR (onServerPrefetch)
+ * const { data, loading, errorItem, isResponseContractValid } = useApiAsyncRef(
+ *   '/users/1',
+ *   { method: 'GET' },
+ *   true, // reactivity
+ *   undefined, // conditions
+ *   undefined, // transformation
+ *   (data) => { // validateResponseContract
+ *     try {
+ *       return { status: 'success', data: S.decodeUnknownSync(userSchema)(data) }
+ *     } catch (e) {
+ *       return { status: 'error', errors: e }
+ *     }
+ *   },
+ *   [ // errorContract
+ *     { status: 404, message: 'User not found' }
+ *   ]
+ * )
+ * ```
+ *
+ * @param path path to request (can be a Ref or Getter)
+ * @param options data for the request (headers, method, etc.)
+ * @param reactivity should reactivity be enabled (automatically re-fetch on deps change)
+ * @param conditions conditions for executing the request (request will wait until true)
+ * @param transformation transforms the received response data
+ * @param validateResponseContract function to validate response data contract. Used to ensure that the API
+ * response matches the expected structure. Highly recommended to use with `@effect/schema`.
+ * It should return `ApiDataValidation` containing a `status` ('success' or 'error')
+ * and the parsed data or errors.
+ * @param errorContract array of expected error contracts for the request (`ApiErrorStorageList`).
+ * Highly recommended to add if there is information about possible request errors. Allows you to predefine
+ * possible errors (by code, status, or custom validation). If an error occurs matching one of these contracts,
+ * it will be automatically processed and made available via the `errorItem` computed property.
+ * @param unmounted whether to stop the request and clear data from cache when component is unmounted
+ * @param apiInstance Api instance (defaults to global Api instance)
+ */
 export declare function useApiAsyncRef<R, T = R>(path?: RefOrNormal<string | undefined>, options?: ApiOptions, reactivity?: boolean, conditions?: RefType<boolean>, transformation?: (data: T, isResponseContractValid?: ApiDataValidation) => ApiData<R>, validateResponseContract?: (data: T) => ApiDataValidation, errorContract?: ApiErrorStorageList, unmounted?: boolean, apiInstance?: ApiInstance): UseApiRef<R>;
-
-// File: src/composables/ref/useApiDelete.d.ts
-import { ApiData, ApiFetch } from '@dxtmisha/functional-basic';
-import { UseApiRequestSetup } from './useApiRequest';
-import { Ref } from 'vue';
-export interface UseApiDeleteSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
-}
+export interface UseApiDeleteSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {}
 export declare function useApiDelete<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiDeleteSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
-
-// File: src/composables/ref/useApiGet.d.ts
-import { ApiData, ApiFetch } from '@dxtmisha/functional-basic';
-import { UseApiRequestSetup } from './useApiRequest';
-import { Ref } from 'vue';
-export interface UseApiGetSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
-}
+export interface UseApiGetSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {}
 export declare function useApiGet<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiGetSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
-
-// File: src/composables/ref/useApiManagementAsyncRef.d.ts
-import { ApiInstance, ArrayToItem, FormattersListColumns, FormattersOptionsList, SearchColumns, ApiDataValidation, SearchFormatList, ApiData, ApiErrorItem, ApiFetch } from '@dxtmisha/functional-basic';
-import { ApiManagementGet, ApiManagementRequest, ApiManagementSearch, ApiManagementValue } from '../../types/apiTypes';
-import { ComputedRef, Ref } from 'vue';
 export declare function useApiManagementAsyncRef<Return extends ApiManagementValue, FormattersOptions extends FormattersOptionsList, Post extends Record<string, any>, Put extends Record<string, any>, Delete extends Record<string, any>, Type extends ApiManagementValue = Return, Item extends ArrayToItem<Return> = ArrayToItem<Return>, ItemFormatters extends FormattersListColumns<Item, FormattersOptions>[number] = FormattersListColumns<Item, FormattersOptions>[number], Columns extends SearchColumns<ItemFormatters> = []>(propsGet: ApiManagementGet<Return, Type>, formattersOptions?: FormattersOptions, searchOptions?: ApiManagementSearch<Item, Columns>, postRequest?: ApiManagementRequest<Post>, putRequest?: ApiManagementRequest<Put>, deleteRequest?: ApiManagementRequest<Delete>, action?: () => Promise<void> | void, apiInstance?: ApiInstance): {
     isValid: ComputedRef<boolean>;
     isResponseContractValid: ComputedRef<boolean>;
-    responseValidationResult: ComputedRef< ApiDataValidation | undefined>;
+    responseValidationResult: ComputedRef<ApiDataValidation | undefined>;
     list: ComputedRef<SearchFormatList<ItemFormatters, Columns>>;
-    readonly data: ComputedRef< ApiData<Return> | undefined>;
-    errorItem: ComputedRef< ApiErrorItem | undefined>;
+    readonly data: ComputedRef<ApiData<Return> | undefined>;
+    errorItem: ComputedRef<ApiErrorItem | undefined>;
     readonly length: ComputedRef<number>;
     lengthData: ComputedRef<number>;
     starting: ComputedRef<boolean>;
@@ -319,22 +282,77 @@ export declare function useApiManagementAsyncRef<Return extends ApiManagementVal
     initSsr: () => void;
     reset: () => Promise<void>;
     abort: () => void;
-    sendPost: (request?: ApiFetch["request"]) => Promise< ApiData<Post> | undefined>;
-    sendPut: (request?: ApiFetch["request"]) => Promise< ApiData<Put> | undefined>;
-    sendDelete: (request?: ApiFetch["request"]) => Promise< ApiData<Delete> | undefined>;
+    sendPost: (request?: ApiFetch["request"]) => Promise<ApiData<Post> | undefined>;
+    sendPut: (request?: ApiFetch["request"]) => Promise<ApiData<Put> | undefined>;
+    sendDelete: (request?: ApiFetch["request"]) => Promise<ApiData<Delete> | undefined>;
 };
-
-// File: src/composables/ref/useApiManagementRef.d.ts
-import { Ref, ComputedRef } from 'vue';
-import { FormattersOptionsList, ApiData, ApiInstance, ArrayToItem, SearchColumns, SearchFormatList, FormattersListColumns, ApiFetch, ApiDataValidation, ApiErrorItem } from '@dxtmisha/functional-basic';
-import { ApiManagementGet, ApiManagementRequest, ApiManagementSearch, ApiManagementValue } from '../../types/apiTypes';
+/**
+ * A powerful composable for comprehensive API request orchestration.
+ * It centrally manages data loading (GET), list formatting, client-side searching,
+ * and mutations (POST, PUT, DELETE) through a single reactive interface.
+ *
+ * @template Return type of data returned by the API
+ * @template FormattersOptions optional formatting rules
+ * @template Post data type for POST creation request
+ * @template Put data type for PUT update request
+ * @template Delete data type for DELETE removal request
+ * @template Type original data type (before transformation)
+ * @template Item type of a single item in the data list
+ * @template ItemFormatters item type after formatters are applied
+ * @template Columns search columns derived from formatting
+ *
+ * @param propsGet main GET request settings (path, reactivity, skeleton, etc.)
+ * @param formattersOptions optional reactive formatting rules
+ * @param searchOptions optional client-side search settings
+ * @param postRequest optional POST mutation settings
+ * @param putRequest optional PUT mutation settings
+ * @param deleteRequest optional DELETE mutation settings
+ * @param action common callback executed after any successful mutation
+ * @param apiInstance API instance for requests (defaults to Api.getItem())
+ *
+ * @returns reactive API management interface
+ *
+ * @note This hook is recommended to be used in tandem with `executeUse` for centralized state management.
+ * By wrapping `useApiManagementRef` in `executeUseProvide` or `executeUseGlobal`, you can ensure
+ * a single source of truth across the component tree or the entire application.
+ *
+ * @remarks
+ * Data formatting guidelines for `formattersOptions`:
+ * - **Recommended for formatting:** Numbers that represent values (prices, counts), dates, currency, units, and statuses.
+ * - **Not recommended for formatting:** Technical identifiers such as ID, UUID, account numbers (if used for logic), types, or internal codes.
+ *
+ * @example
+ * // 1. Comprehensive API orchestration
+ * const products = useApiManagementRef(
+ *   {
+ *     path: '/api/v1/products',
+ *     skeleton: () => Array(5).fill({ id: 0, name: 'Loading...', price: 0 })
+ *   },
+ *   {
+ *     // Formatters for display
+ *     price: (v) => `${v} USD`,
+ *     created_at: (v) => new Date(v).toLocaleDateString()
+ *   },
+ *   {
+ *     // Client-side search setup
+ *     columns: ['name', 'category']
+ *   },
+ *   { path: '/api/v1/products' }, // POST (create)
+ *   { path: (data) => `/api/v1/products/${data.id}` }, // PUT (update)
+ *   { path: (data) => `/api/v1/products/${data.id}` }  // DELETE (remove)
+ * );
+ *
+ * // Accessing data:
+ * // products.list.value -> processed, formatted, and searched list
+ * // products.sendPost({ name: 'New Product', price: 100 }) -> execute mutation
+ */
 export declare function useApiManagementRef<Return extends ApiManagementValue, FormattersOptions extends FormattersOptionsList, Post extends Record<string, any>, Put extends Record<string, any>, Delete extends Record<string, any>, Type extends ApiManagementValue = Return, Item extends ArrayToItem<Return> = ArrayToItem<Return>, ItemFormatters extends FormattersListColumns<Item, FormattersOptions>[number] = FormattersListColumns<Item, FormattersOptions>[number], Columns extends SearchColumns<ItemFormatters> = []>(propsGet: ApiManagementGet<Return, Type>, formattersOptions?: FormattersOptions, searchOptions?: ApiManagementSearch<Item, Columns>, postRequest?: ApiManagementRequest<Post>, putRequest?: ApiManagementRequest<Put>, deleteRequest?: ApiManagementRequest<Delete>, action?: () => Promise<void> | void, apiInstance?: ApiInstance): {
     isValid: ComputedRef<boolean>;
     isResponseContractValid: ComputedRef<boolean>;
-    responseValidationResult: ComputedRef< ApiDataValidation | undefined>;
+    responseValidationResult: ComputedRef<ApiDataValidation | undefined>;
     list: ComputedRef<SearchFormatList<ItemFormatters, Columns>>;
     readonly data: ComputedRef<ApiData<Return> | undefined>;
-    errorItem: ComputedRef< ApiErrorItem | undefined>;
+    errorItem: ComputedRef<ApiErrorItem | undefined>;
     readonly length: ComputedRef<number>;
     lengthData: ComputedRef<number>;
     starting: ComputedRef<boolean>;
@@ -354,34 +372,16 @@ export declare function useApiManagementRef<Return extends ApiManagementValue, F
     sendPut: (request?: ApiFetch["request"]) => Promise<ApiData<Put> | undefined>;
     sendDelete: (request?: ApiFetch["request"]) => Promise<ApiData<Delete> | undefined>;
 };
-
-// File: src/composables/ref/useApiPost.d.ts
-import { ApiData, ApiFetch } from '@dxtmisha/functional-basic';
-import { UseApiRequestSetup } from './useApiRequest';
-import { Ref } from 'vue';
-export interface UseApiPostSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
-}
+export interface UseApiPostSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {}
 export declare function useApiPost<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiPostSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
-
-// File: src/composables/ref/useApiPut.d.ts
-import { ApiData, ApiFetch } from '@dxtmisha/functional-basic';
-import { UseApiRequestSetup } from './useApiRequest';
-import { Ref } from 'vue';
-export interface UseApiPutSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
-}
+export interface UseApiPutSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {}
 export declare function useApiPut<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiPutSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
-
-// File: src/composables/ref/useApiRef.d.ts
-import { ComputedRef, Ref } from 'vue';
-import { ApiInstance, ApiData, ApiDataValidation, ApiErrorStorageList, ApiErrorItem } from '@dxtmisha/functional-basic';
-import { ApiOptions } from '../../types/apiTypes';
-import { RefOrNormal, RefType } from '../../types/refTypes';
 export interface UseApiRef<R> {
     data: ComputedRef<ApiData<R> | undefined>;
     item: Ref<ApiData<R> | undefined>;
@@ -402,14 +402,58 @@ export interface UseApiRef<R> {
     stop(): void;
     abort(): void;
 }
+/**
+ * Main reactive composable for working with API requests in Vue.
+ * Automatically handles SSR, reactivity, caching, error storage, data validation, and transformation.
+ *
+ * @example
+ * ```typescript
+ * import { Schema as S } from '@effect/schema'
+ * import { useApiRef } from '@dxtmisha/functional'
+ *
+ * // Define a schema using @effect/schema
+ * const userSchema = S.Struct({ id: S.Number, name: S.String })
+ *
+ * const { data, loading, errorItem, isResponseContractValid } = useApiRef(
+ *   '/users/1',
+ *   { method: 'GET' },
+ *   true, // reactivity
+ *   undefined, // conditions
+ *   (data) => ({ ...data, isTransformed: true }), // transformation
+ *   (data) => { // validateResponseContract
+ *     try {
+ *       return { status: 'success', data: S.decodeUnknownSync(userSchema)(data) }
+ *     } catch (e) {
+ *       return { status: 'error', errors: e }
+ *     }
+ *   },
+ *   [ // errorContract (ApiErrorStorageList)
+ *     {
+ *       status: 404,
+ *       message: 'User not found'
+ *     }
+ *   ]
+ * )
+ * ```
+ *
+ * @param path path to request (can be a Ref or Getter)
+ * @param options data for the request (headers, method, etc.)
+ * @param reactivity should reactivity be enabled (automatically re-fetch on deps change)
+ * @param conditions conditions for executing the request (request will wait until true)
+ * @param transformation transforms the received response data
+ * @param validateResponseContract function to validate response data contract. Used to ensure that the API
+ * response matches the expected structure. Highly recommended to use with `@effect/schema`.
+ * It should return `ApiDataValidation` containing a `status` ('success' or 'error')
+ * and the parsed data or errors.
+ * @param errorContract array of expected error contracts for the request (`ApiErrorStorageList`).
+ * Highly recommended to add if there is information about possible request errors. Allows you to predefine
+ * possible errors (by code, status, or custom validation). If an error occurs matching one of these contracts,
+ * it will be automatically processed and made available via the `errorItem` computed property.
+ * @param unmounted whether to stop the request and clear data from cache when component is unmounted
+ * @param apiInstance Api instance (defaults to global Api instance)
+ */
 export declare function useApiRef<R, T = R>(path?: RefOrNormal<string | undefined>, options?: ApiOptions, reactivity?: boolean, conditions?: RefType<boolean>, transformation?: (data: T, isResponseContractValid?: ApiDataValidation) => ApiData<R>, validateResponseContract?: (data: T) => ApiDataValidation, errorContract?: ApiErrorStorageList, unmounted?: boolean, apiInstance?: ApiInstance): UseApiRef<R>;
 export declare const setApiRefGlobalConditions: (conditions: RefType<any>) => void;
-
-// File: src/composables/ref/useApiRequest.d.ts
-import { ApiInstance, ApiMethodItem, ApiData, ApiFetch, ApiErrorStorageList, ApiDataValidation } from '@dxtmisha/functional-basic';
-import { ApiOptions } from '../../types/apiTypes';
-import { RefOrNormal } from '../../types/refTypes';
-import { Ref } from 'vue';
 export interface UseApiRequestSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> {
     path?: RefOrNormal<string | undefined>;
     method?: ApiMethodItem;
@@ -426,48 +470,23 @@ export declare function useApiRequest<T, Request extends ApiFetch['request'] = A
     loading: Ref<boolean, boolean>;
     send(request?: Request): Promise<Return | undefined>;
 };
-
-// File: src/composables/ref/useBroadcastValueRef.d.ts
-import { Ref } from 'vue';
-type BroadcastValueItem<T> = T | string | undefined;
-export declare function useBroadcastValueRef<T>(name: string, defaultValue?: T | string | (() => (T | string))): Ref<BroadcastValueItem<T>>;
-
-// File: src/composables/ref/useCookieRef.d.ts
-import { Ref } from 'vue';
-import { CookieOptions } from '@dxtmisha/functional-basic';
+export declare function useBroadcastValueRef<T>(name: string, defaultValue?: T | string | (() => (T | string))): Ref<T | string | undefined>;
 export declare function useCookieRef<T>(name: string, defaultValue?: T | string | (() => (T | string)), options?: CookieOptions): Ref<T | string | undefined>;
-
-// File: src/composables/ref/useFormattersRef.d.ts
-import { FormattersListProp, FormattersOptionsList, FormattersReturn } from '@dxtmisha/functional-basic';
-import { RefType } from '../../types/refTypes';
-import { ComputedRef } from 'vue';
 export declare function useFormattersRef<Options extends FormattersOptionsList = FormattersOptionsList, List extends FormattersListProp = FormattersListProp>(list: RefType<List | undefined>, options: Options): {
     listFormat: ComputedRef<FormattersReturn<List, Options>>;
     length: ComputedRef<number>;
 };
-
-// File: src/composables/ref/useGeoIntlRef.d.ts
-import { GeoIntlRef } from '../../classes/ref/GeoIntlRef';
 export declare function useGeoIntlRef(): GeoIntlRef;
-
-// File: src/composables/ref/useGeoUnitRef.d.ts
-import { GeoUnitRef } from '../../classes/ref/GeoUnitRef';
 export declare function useGeoUnitRef(): GeoUnitRef;
-
-// File: src/composables/ref/useHashRef.d.ts
-import { ShallowRef } from 'vue';
 export declare function useHashRef<T>(name: string, defaultValue?: T | (() => T)): ShallowRef<T>;
-
-// File: src/composables/ref/useLazyItemByMarginRef.d.ts
-import { RefType } from '../../types/refTypes';
-export type LazyItemByMargin = { rootMargin: string; item: any; };
-export declare const useLazyItemByMarginRef: (element: RefType<HTMLElement | undefined>, rootMargin: string) => {
-    lazyItemStatus: any;
-    readonly lazyItem: any;
+export type LazyItemByMargin = {
+    rootMargin: string;
+    item: ReturnType<typeof useLazyRef>;
+};
+export declare const useLazyItemByMarginRef: (element: RefType<HTMLElement | undefined>, rootMargin?: string) => {
+    lazyItemStatus: ShallowRef<boolean, boolean>;
+    readonly lazyItem: LazyItem | undefined;
 };
-
-// File: src/composables/ref/useLazyRef.d.ts
-import { Ref, ShallowRef } from 'vue';
 export type LazyItem = {
     status: ShallowRef<boolean>;
     ratio: ShallowRef<number>;
@@ -477,21 +496,14 @@ export type LazyItem = {
 export type LazyList = Record<string, LazyItem>;
 export declare const useLazyRef: (options?: IntersectionObserverInit) => {
     intersectionObserver: IntersectionObserver | undefined;
-    getItem(element: HTMLElement): LazyItem;
+    getItem(element?: HTMLElement): LazyItem | undefined;
     addLazyItem(element: Ref<HTMLElement | undefined>): ShallowRef<boolean, boolean>;
     removeLazyItem: (element?: HTMLElement) => void;
     disconnectLazy: () => void | undefined;
 };
-
-// File: src/composables/ref/useLoadingRef.d.ts
-import { ShallowRef } from 'vue';
 export declare function useLoadingRef(): ShallowRef<boolean, boolean>;
-
-// File: src/composables/ref/useMeta.d.ts
-import { MetaRobots, MetaStatic } from '@dxtmisha/functional-basic';
-import { Ref } from 'vue';
 export declare const useMeta: () => Readonly<{
-    meta: typeof MetaStatic;
+    meta: Meta;
     title: Ref<string, string>;
     keyword: Ref<string, string>;
     description: Ref<string, string>;
@@ -512,10 +524,10 @@ export declare const useMeta: () => Readonly<{
     setCanonical: (value: string) => void;
     setRobots: (value: MetaRobots) => void;
     setSiteName: (value: string) => void;
-    setSuffix: (suffix: string) => typeof MetaStatic;
-} & {
+    setSuffix: (suffix: string) => void;
+}> & {
     init(): Readonly<{
-        meta: typeof MetaStatic;
+        meta: Meta;
         title: Ref<string, string>;
         keyword: Ref<string, string>;
         description: Ref<string, string>;
@@ -536,21 +548,11 @@ export declare const useMeta: () => Readonly<{
         setCanonical: (value: string) => void;
         setRobots: (value: MetaRobots) => void;
         setSiteName: (value: string) => void;
-        setSuffix: (suffix: string) => typeof MetaStatic;
+        setSuffix: (suffix: string) => void;
     }>;
     destroyExecute?(): void;
-}>;
-
-// File: src/composables/ref/useQueryRef.d.ts
-import { ShallowRef } from 'vue';
+};
 export declare function useQueryRef<T>(name: string, defaultValue?: T | (() => T)): ShallowRef<T>;
-
-// File: src/composables/ref/useRouterList.d.ts
-import { Ref, ComputedRef } from 'vue';
-import { NumberOrString } from '@dxtmisha/functional-basic';
-import { ConstrBind } from '../../types/constructorTypes';
-import { ListDataBasic } from '../../types/listTypes';
-import { RefType } from '../../types/refTypes';
 export declare const useRouterList: <T extends ListDataBasic>(list: RefType<ConstrBind<T>[] | undefined>, selected?: Ref<string> | string, hasTo?: boolean) => {
     item: ComputedRef<T | undefined>;
     selected: Ref<string, string>;
@@ -559,65 +561,50 @@ export declare const useRouterList: <T extends ListDataBasic>(list: RefType<Cons
     to: (name?: string) => void;
     toMain(): void;
 };
-
-// File: src/composables/ref/useSearchRef.d.ts
-import { Ref, ComputedRef } from 'vue';
-import { SearchColumns, SearchFormatList, SearchItem, SearchOptions } from '@dxtmisha/functional-basic';
-import { SearchListInput } from '../../types/searchTypes';
-export declare function useSearchRef<T extends SearchItem, K extends SearchColumns<T>>(list: SearchListInput<T>, columns: K, value?: Ref<string>, options?: SearchOptions): {
+export declare function useSearchRef<T extends SearchItem, K extends SearchColumns<T>>(list: SearchListInput<T>, columns?: SearchColumnsInput<T, K>, value?: Ref<string>, options?: SearchOptions): {
     isSearch: ComputedRef<boolean>;
     search: Ref<string, string>;
     loading: Ref<boolean, boolean>;
     listSearch: ComputedRef<SearchFormatList<T, K>>;
     length: ComputedRef<number>;
 };
-
-// File: src/composables/ref/useSearchValueRef.d.ts
-import { Ref } from 'vue';
-import { SearchList, SearchColumns, SearchItem } from '@dxtmisha/functional-basic';
 export declare function useSearchValueRef<T extends SearchItem, K extends SearchColumns<T>>(item: SearchList<T, K>, value?: Ref<string>): {
     search: Ref<string, string>;
     searchDelay: Ref<string, string>;
     loading: Ref<boolean, boolean>;
 };
-
-// File: src/composables/ref/useSessionRef.d.ts
-import { Ref } from 'vue';
 export declare function useSessionRef<T>(name: string, defaultValue?: T | (() => T)): Ref<T | undefined>;
-
-// File: src/composables/ref/useStorageRef.d.ts
-import { Ref } from 'vue';
 export declare function useStorageRef<T>(name: string, defaultValue?: T | (() => T), cache?: number): Ref<T | undefined>;
-
-// File: src/composables/ref/useTranslateRef.d.ts
-import { ShallowRef } from 'vue';
-import { TranslateInstance, TranslateList } from '@dxtmisha/functional-basic';
+/**
+ * Getting the translated text by an array of keys or a string with a key.
+ *
+ * It returns a `ShallowRef` that automatically updates when the global language changes.
+ * Use `as const` for arrays to ensure proper TypeScript key inference.
+ *
+ * ### Examples:
+ * ```typescript
+ * // 1. Using the main composable
+ * const translations = useTranslateRef(['home.title', 'home.description'] as const);
+ *
+ * // 2. Using the shorthand 't'
+ * const labels = t(['button.save', 'button.cancel'] as const);
+ * ```
+ *
+ * @param names a string or an array with keys
+ * @param translateInstance a translate instance
+ */
 export declare function useTranslateRef<T extends (string | string[])[]>(names: T, translateInstance?: TranslateInstance): ShallowRef<TranslateList<T>>;
+/**
+ * Shorthand for useTranslateRef.
+ * Use `as const` for arrays to ensure proper TypeScript key inference.
+ *
+ * @param names a string or an array with keys
+ */
 export declare const t: <T extends string[]>(names: T) => ShallowRef<TranslateList<T>>;
-
-// File: src/flags.d.ts
 export declare const uiMakeFlags: () => void;
-
-// File: src/functions/basic.d.ts
-export * from '@dxtmisha/functional-basic';
-
-// File: src/functions/computedAsync.d.ts
-import { ComputedRef, DebuggerOptions } from 'vue';
 export declare function computedAsync<R>(getter: (() => Promise<R>) | (() => R) | R, initialState?: (() => R) | R, ignore?: R, debugOptions?: DebuggerOptions): ComputedRef<R | undefined>;
-
-// File: src/functions/computedByLanguage.d.ts
-import { ComputedGetter, ComputedRef, DebuggerOptions } from 'vue';
 export declare function computedByLanguage<T, R extends (T | undefined) = T | undefined>(getter: ComputedGetter<R>, getterNone?: R | (() => R), conditions?: () => boolean, debugOptions?: DebuggerOptions): ComputedRef<R>;
-
-// File: src/functions/computedEternity.d.ts
-import { Ref } from 'vue';
 export declare function computedEternity<T>(getter: () => Promise<T> | T, initialState?: (() => T) | T): Ref<T, T>;
-
-// File: src/functions/dxtFunctionalPlugin.d.ts
-import { Plugin } from 'vue';
-import { InputSocialIcons } from '@dxtmisha/media';
-import { ApiConfig, ErrorCenterCauseList, ErrorCenterHandlerCallback, ErrorCenterHandlerList, IconsConfig, TranslateConfig } from '@dxtmisha/functional-basic';
-import { Router } from 'vue-router';
 export interface FunctionalPluginOptions {
     api?: ApiConfig;
     translate?: TranslateConfig;
@@ -630,9 +617,25 @@ export interface FunctionalPluginOptions {
     errorHandlers?: ErrorCenterHandlerList;
     errorCallbacks?: ErrorCenterHandlerCallback[];
 }
+/**
+ * Vue plugin for initializing and configuring global functional services
+ * (Api, Translate, Icons, Meta).
+ *
+ * @example
+ * ```typescript
+ * import { createApp } from 'vue'
+ * import { dxtFunctionalPlugin } from '@dxtmisha/functional'
+ * import router from './router'
+ *
+ * const app = createApp(App)
+ * app.use(dxtFunctionalPlugin, {
+ *   api: { url: 'https://api.example.com' },
+ *   metaSuffix: ' | My App',
+ *   router
+ * })
+ * ```
+ */
 export declare const dxtFunctionalPlugin: Plugin;
-
-// File: src/functions/executeUse.d.ts
 export declare enum ExecuteUseType {
     global = "global",
     provide = "provide",
@@ -642,152 +645,130 @@ export type ExecuteUseReturn<R> = Readonly<R & {
     init(): Readonly<R>;
     destroyExecute?(): void;
 }>;
+/**
+ * Creates a managed singleton that encapsulates initialization logic and access mode.
+ *
+ * It supports three initialization strategies:
+ * - `global`: A single instance for the entire application.
+ * - `provide`: Shared via provide/inject in the component tree (standard for Vue 3).
+ * - `local`: A single instance within the closure of the returned function.
+ *
+ * @template R return type of the factory function
+ * @template O argument types for the factory function
+ * @template RI instance type with management methods
+ *
+ * @param callback initialization function
+ * @param type initialization strategy (defaults to provide)
+ *
+ * @returns {function} accessor function for the singleton
+ *
+ * @remarks
+ * Use this function in the following cases:
+ * - **API Services:** Always wrap API clients to ensure a single connection point and unified state.
+ * - **Resource Optimization:** For functions where creating multiple instances is undesirable (e.g., heavy objects, event buses).
+ * - **Shared State:** To share reactive state within a component tree using the `provide` strategy.
+ * - **External SDKs:** Initializing third-party libraries (analytics, maps, charts) that should be singletons.
+ *
+ * @example
+ * // 1. Global API singleton (useApiGet)
+ * export const useUserApi = executeUseGlobal(() => {
+ *   return useApiGet('/api/user');
+ * });
+ *
+ * @example
+ * // 2. Shared Reactive State
+ * export const useFeatureState = executeUseProvide(() => {
+ *   // Reactive logic here
+ *   const items = [];
+ *   const addItem = (item) => items.push(item);
+ *   return { items, addItem };
+ * });
+ *
+ * @example
+ * // 3. Local Caching
+ * export const useHeavyResource = executeUseLocal((config) => {
+ *   return new HeavyResource(config);
+ * });
+ *
+ * @example
+ * // 4. Complex API Service (useApiManagementRef)
+ * export const useUserManagement = executeUseGlobal(() => {
+ *   return useApiManagementRef(
+ *     { path: '/api/users' },                 // GET setup
+ *     { date: (v) => new Date(v).toLocaleString() }, // Formatters
+ *     { columns: ['name', 'email'] },         // Search
+ *     { path: '/api/users' },                 // POST (create)
+ *     { path: (o) => `/api/users/${o.id}` },  // PUT (update)
+ *     { path: (o) => `/api/users/${o.id}` }   // DELETE (remove)
+ *   );
+ * });
+ *
+ * // Usage in component:
+ * // const { list, loading, sendPost, sendDelete } = useUserManagement();
+ */
 export declare function executeUse<R, O extends any[], RI extends ExecuteUseReturn<R> = ExecuteUseReturn<R>>(callback: (...args: O) => R, type?: ExecuteUseType): ((...args: O) => RI) | (() => RI);
-export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<R & { init(): Readonly<R>; destroyExecute?(): void; }>) | (() => Readonly<R & { init(): Readonly<R>; destroyExecute?(): void; }>);
-export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & { init(): Readonly<R>; destroyExecute?(): void; }>) | (() => Readonly<R & { init(): Readonly<R>; destroyExecute?(): void; }>);
-export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & { init(): Readonly<R>; destroyExecute?(): void; }>) | (() => Readonly<R & { init(): Readonly<R>; destroyExecute?(): void; }>);
+/**
+ * Creates a global singleton.
+ *
+ * @remarks
+ * See {@link executeUse} for more details.
+ *
+ * @param callback Initialization function
+ */
+export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<R & {
+    init(): Readonly<R>;
+    destroyExecute?(): void;
+}>) | (() => Readonly<R & {
+    init(): Readonly<R>;
+    destroyExecute?(): void;
+}>);
+/**
+ * Creates a component-scoped singleton.
+ *
+ * @remarks
+ * Best for sharing state within a component sub-tree.
+ * See {@link executeUse} for more details.
+ *
+ * @param callback Initialization function
+ */
+export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
+    init(): Readonly<R>;
+    destroyExecute?(): void;
+}>) | (() => Readonly<R & {
+    init(): Readonly<R>;
+    destroyExecute?(): void;
+}>);
+/**
+ * Creates a local singleton.
+ *
+ * @remarks
+ * Best for internal state preservation within a closure.
+ * See {@link executeUse} for more details.
+ *
+ * @param callback Initialization function
+ */
+export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
+    init(): Readonly<R>;
+    destroyExecute?(): void;
+}>) | (() => Readonly<R & {
+    init(): Readonly<R>;
+    destroyExecute?(): void;
+}>);
 export declare function executeUseGlobalInit(): void;
-
-// File: src/functions/getInject.d.ts
 export declare function getInject<T>(name: string): T | undefined;
-
-// File: src/functions/getOptions.d.ts
-import { ApiFetch } from '@dxtmisha/functional-basic';
-import { ApiOptions } from '../types/apiTypes';
-import { RefOrNormal } from '../types/refTypes';
 export declare const getOptions: (options?: ApiOptions) => RefOrNormal<ApiFetch>;
-
-// File: src/functions/ref/executeFunctionRef.d.ts
-import { RefOrNormalOrFunction } from '../../types/refTypes';
 export declare function executeFunctionRef<T>(data: RefOrNormalOrFunction<T>): T;
-
-// File: src/functions/ref/getApiErrorRef.d.ts
-import { ComputedRef } from 'vue';
-import { ApiData, ApiErrorItem } from '@dxtmisha/functional-basic';
-import { RefType } from '../../types/refTypes';
 export declare function getApiErrorRef<R>(data: RefType<ApiData<R> | undefined>): ComputedRef<ApiErrorItem | undefined>;
-
-// File: src/functions/ref/getBindRef.d.ts
-import { ComputedRef } from 'vue';
-import { ItemList } from '@dxtmisha/functional-basic';
-import { RefOrNormal } from '../../types/refTypes';
 export declare function getBindRef<T, R extends ItemList>(value: RefOrNormal<T | R> | undefined, nameExtra?: RefOrNormal<ItemList> | string, name?: string): ComputedRef<R>;
-
-// File: src/functions/ref/getRef.d.ts
-import { RefOrNormal } from '../../types/refTypes';
 export declare function getRef<T>(item: RefOrNormal<T>): T;
-
-// File: src/functions/ref/render.d.ts
-import { VNode } from 'vue';
-import { ItemList } from '@dxtmisha/functional-basic';
-import { RawChildren, RawSlots } from '../../types/refTypes';
 export declare function render<T extends ItemList>(name: string | any, props?: T, children?: RawChildren | RawSlots, index?: string): VNode;
-
-// File: src/functions/ref/setRef.d.ts
-import { Ref } from 'vue';
 export declare function setRef<T>(item: Ref<T>, value: T): void;
-
-// File: src/functions/ref/toRefItem.d.ts
-import { Ref } from 'vue';
-import { RefOrNormal } from '../../types/refTypes';
 export declare function toRefItem<T>(item: RefOrNormal<T>): Ref<T>;
-
-// File: src/functions/render/getBind.d.ts
-import { ItemList } from '@dxtmisha/functional-basic';
-import { ConstrBind } from '../../types/constructorTypes';
 export declare function getBind<T, R extends ItemList>(value: T | R | undefined | null, nameExtra?: ItemList | string, name?: string, except?: boolean): ConstrBind<R>;
-
-// File: src/functions/render/getClassName.d.ts
-import { ItemList } from '@dxtmisha/functional-basic';
 export declare function getClassName<T extends ItemList>(props?: T): string | undefined;
-
-// File: src/functions/render/getIndexForRender.d.ts
-import { ItemList } from '@dxtmisha/functional-basic';
 export declare function getIndexForRender<T extends ItemList>(name: string | any, props?: T, index?: string): string | undefined;
-
-// File: src/functions/toBind.d.ts
-import { ItemList } from '@dxtmisha/functional-basic';
-import { ConstrBind } from '../types/constructorTypes';
 export declare function toBind<R extends ItemList = ItemList>(extra: ItemList, value: ItemList): ConstrBind<R>;
-
-// File: src/functions/toBinds.d.ts
-import { ItemList } from '@dxtmisha/functional-basic';
-import { ConstrBind } from '../types/constructorTypes';
 export declare function toBinds<R extends ItemList = ItemList>(...values: (ItemList | undefined)[]): ConstrBind<R>;
-
-// File: src/library.d.ts
-export * from './classes/design/DesignAbstract';
-export * from './classes/design/DesignAsyncAbstract';
-export * from './classes/design/DesignChanged';
-export * from './classes/design/DesignComp';
-export * from './classes/design/DesignComponents';
-export * from './classes/design/DesignConstructorAbstract';
-export * from './classes/ref/DatetimeRef';
-export * from './classes/ref/EffectScopeGlobal';
-export * from './classes/ref/EventRef';
-export * from './classes/ref/GeoFlagRef';
-export * from './classes/ref/GeoIntlRef';
-export * from './classes/ref/GeoRef';
-export * from './classes/ref/GeoUnitRef';
-export * from './classes/ref/ListDataRef';
-export * from './classes/ref/RouterItemRef';
-export * from './classes/ref/ScrollbarWidthRef';
-export * from './composables/ref/useApiAsyncRef';
-export * from './composables/ref/useApiDelete';
-export * from './composables/ref/useApiGet';
-export * from './composables/ref/useApiManagementAsyncRef';
-export * from './composables/ref/useApiManagementRef';
-export * from './composables/ref/useApiPost';
-export * from './composables/ref/useApiPut';
-export * from './composables/ref/useApiRef';
-export * from './composables/ref/useApiRequest';
-export * from './composables/ref/useBroadcastValueRef';
-export * from './composables/ref/useCookieRef';
-export * from './composables/ref/useFormattersRef';
-export * from './composables/ref/useGeoIntlRef';
-export * from './composables/ref/useGeoUnitRef';
-export * from './composables/ref/useHashRef';
-export * from './composables/ref/useLazyItemByMarginRef';
-export * from './composables/ref/useLazyRef';
-export * from './composables/ref/useLoadingRef';
-export * from './composables/ref/useMeta';
-export * from './composables/ref/useQueryRef';
-export * from './composables/ref/useRouterList';
-export * from './composables/ref/useSearchRef';
-export * from './composables/ref/useSearchValueRef';
-export * from './composables/ref/useSessionRef';
-export * from './composables/ref/useStorageRef';
-export * from './composables/ref/useTranslateRef';
-export * from './functions/basic';
-export * from './functions/computedAsync';
-export * from './functions/computedByLanguage';
-export * from './functions/computedEternity';
-export * from './functions/dxtFunctionalPlugin';
-export * from './functions/executeUse';
-export * from './functions/getInject';
-export * from './functions/getOptions';
-export * from './functions/ref/executeFunctionRef';
-export * from './functions/ref/getApiErrorRef';
-export * from './functions/ref/getBindRef';
-export * from './functions/ref/getRef';
-export * from './functions/ref/render';
-export * from './functions/ref/setRef';
-export * from './functions/ref/toRefItem';
-export * from './functions/render/getBind';
-export * from './functions/render/getClassName';
-export * from './functions/render/getIndexForRender';
-export * from './functions/toBind';
-export * from './functions/toBinds';
-export * from './types/apiTypes';
-export * from './types/constructorTypes';
-export * from './types/listTypes';
-export * from './types/refTypes';
-export * from './types/searchTypes';
-
-// File: src/types/apiTypes.d.ts
-import { ApiData, ApiDataValidation, ApiDefaultValue, ApiErrorStorageList, ApiFetch, ApiMethodItem, SearchColumns, SearchItem, SearchOptions } from '@dxtmisha/functional-basic';
-import { RefOrNormal, RefType } from './refTypes';
-import { Ref } from 'vue';
 export type ApiOptions = ApiMethodItem | RefOrNormal<ApiFetch>;
 export type ApiManagementValue = ApiDefaultValue | ApiDefaultValue[];
 export type ApiManagementGet<Return extends ApiManagementValue, Type extends ApiManagementValue = Return> = {
@@ -817,23 +798,28 @@ export type ApiManagementRequest<T, Request extends ApiFetch['request'] = ApiFet
     toData?: boolean;
     options?: ApiOptions;
 };
-
-// File: src/types/constructorTypes.d.ts
-import { Ref, PropType, ComputedRef } from 'vue';
-import { Undefined } from '@dxtmisha/functional-basic';
-import { RefOrNormal, RefType } from './refTypes';
 export type ConstrItem = Record<string, any>;
-export type ConstrValue<T = any> = { value?: T; };
+export type ConstrValue<T = any> = {
+    value?: T;
+};
 export type ConstrComponent = Record<string, any>;
-export type ConstrComponentMod<P extends ConstrItem> = ConstrItem | { [K in keyof P]?: RefOrNormal<P[K]>; };
-export type ConstrExpose<E extends Element, EXPOSE extends ConstrItem> = EXPOSE & { elementHtml?: ComputedRef<E | undefined>; };
+export type ConstrComponentMod<P extends ConstrItem> = ConstrItem | {
+    [K in keyof P]?: RefOrNormal<P[K]>;
+};
+export type ConstrExpose<E extends Element, EXPOSE extends ConstrItem> = EXPOSE & {
+    elementHtml?: ComputedRef<E | undefined>;
+};
 export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 export type ConstrEmitItem<T extends ConstrItem> = T[keyof T];
-export type ConstrEmit<T extends ConstrItem = ConstrItem> = UnionToIntersection<ConstrEmitItem<{ [K in keyof T]: (evt: K, ...args: T[K]) => void; }>>;
+export type ConstrEmit<T extends ConstrItem = ConstrItem> = UnionToIntersection<ConstrEmitItem<{
+    [K in keyof T]: (evt: K, ...args: T[K]) => void;
+}>>;
 export type ConstrClassObject = Record<string, boolean | undefined>;
 export type ConstrClass = string | (string | ConstrClass | Undefined)[] | ConstrClassObject;
 export type ConstrClassList = Record<string, ConstrClass>;
-export type ConstrClasses = { main: ConstrClass; } & ConstrClassList;
+export type ConstrClasses = {
+    main: ConstrClass;
+} & ConstrClassList;
 export type ConstrStylesItem = string | null;
 export type ConstrStyles = Record<string, ConstrStylesItem> | ConstrStyles[];
 export type ConstrOptions<COMP extends ConstrComponent, EMITS extends ConstrItem, P extends ConstrItem> = {
@@ -849,7 +835,10 @@ export type ConstrSetup<E extends Element, CLASSES extends ConstrClasses, SETUP
     classes: RefType<CLASSES>;
     styles: RefType<ConstrStyles>;
 } & SETUP;
-export type ConstrRegistration = { flag?: boolean; translate?: Record<string, string>; };
+export type ConstrRegistration = {
+    flag?: boolean;
+    translate?: Record<string, string>;
+};
 export type ConstrBind<T> = T & Record<string, any> & {
     key?: string;
     class?: ConstrClass;
@@ -862,12 +851,12 @@ export type ConstrPropItemOptions<T = any> = {
     validator?(value: any, props: any): boolean;
 };
 export type ConstrPropItem<T = any> = ConstrPropItemOptions<T> | PropType<T>;
-export type ConstrProps<P = Record<string, any>> = { [K in keyof P]: ConstrPropItem<P[K]>; };
-export type ConstrHrefProps = { href?: string; };
-
-// File: src/types/listTypes.d.ts
-import { NumberOrString, NumberOrStringOrBoolean } from '@dxtmisha/functional-basic';
-import { ConstrBind } from './constructorTypes';
+export type ConstrProps<P = Record<string, any>> = {
+    [K in keyof P]: ConstrPropItem<P[K]>;
+};
+export type ConstrHrefProps = {
+    href?: string;
+};
 export type ListType = 'item' | 'space' | 'line' | 'subtitle' | 'html' | 'menu' | 'menu-group' | 'group';
 export type ListDataBasic = {
     label?: NumberOrString;
@@ -895,18 +884,16 @@ export type ListSelectedItem = NumberOrStringOrBoolean;
 export type ListSelectedList = ListSelectedItem | ListSelectedItem[];
 export type ListName = string | number | undefined;
 export type ListNames = ListName[];
-
-// File: src/types/refTypes.d.ts
-import { ComputedRef, Ref, VNode, VNodeArrayChildren } from 'vue';
 export type RefType<T> = ComputedRef<T> | Ref<T>;
 export type RefUndefined<T> = RefType<T | undefined>;
 export type RefOrNormal<T> = RefType<T> | T;
 export type RefOrNormalOrFunction<T> = RefOrNormal<T> | (() => RefOrNormal<T>);
 export type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
-export type RawSlots = { [name: string]: unknown; $stable?: boolean; };
-
-// File: src/types/searchTypes.d.ts
-import { RefOrNormal } from './refTypes';
-import { SearchItem, SearchListValue } from '@dxtmisha/functional-basic';
+export type RawSlots = {
+    [name: string]: unknown;
+    $stable?: boolean;
+};
 export type SearchListValueRef<T extends SearchItem> = RefOrNormal<SearchListValue<T>>;
-export type SearchListInput<T extends SearchItem> = SearchListValueRef<T> | (() => SearchListValueRef<T>);
+export type SearchListInput<T extends SearchItem> = SearchListValueRef<T> | (() => SearchListValueRef<T>);
+export type SearchColumnsRef<T extends SearchItem, K extends SearchColumns<T>> = RefOrNormal<K>;
+export type SearchColumnsInput<T extends SearchItem, K extends SearchColumns<T>> = SearchColumnsRef<T, K> | (() => SearchColumnsRef<T, K>);