@dxtmisha/functional 1.13.5 → 1.14.0

package/CHANGELOG.md

@@ -2,8 +2,26 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.14.0] - 2026-06-22
+
+### Added
+- **useQueryRef**: Introduced a new Vue 3 reactive composable to manage URL query/GET parameters reactively, mimicking `useHashRef` behavior.
+- **useQueryRef**: Added `useQueryRef.test.ts` unit test suite to validate parameter retrieval, reactive updates, and event callbacks.
+
+### Fixed
+- **GeoRef**: Updated `GeoRef.test.ts` assertions for the `'en-VN'` locale to expect country `'VN'` and language `'vi'` to align with the country-first localization resolution updates.
+
+## [1.13.7] - 2026-06-19
+
+### Added
+- **GeoRef**: Added static reactive `getLocation()`, `getLocationCountry()`, and `getLocationLanguage()` methods returning isolated `ComputedRef<string>` representations of location components.
+
+### Fixed
+- **Tests**: Adjusted test assertions in `GeoRef.test.ts` for `'en-VN'` to expect country `'VN'` and standard `'en-VN'` under the country-first matching priority.
+
 ## [1.13.5] - 2026-06-17
 
+
 ### Changed / Improved
 - **GeoRef**: Refactored static getters (`getCountry`, `getLanguage`, `getStandard`, `getFirstDay`) to use request-isolated computed references via `ServerStorage.get`. This isolates their reactive state per request, resolving potential cross-request state pollution during SSR.
 

package/ai-description.md

@@ -0,0 +1,16 @@
+Core Purpose: Provides a structured, reactive framework for Vue 3 component design and API orchestration. It simplifies complex UI state management, internationalization, and asynchronous API interactions through specialized classes and composables.
+
+Key Expositions:
+- Design Construction: DesignAbstract, DesignAsyncAbstract, and DesignComponents for building complex component structures with lifecycle hooks and automated change tracking.
+- API Orchestration: useApiRef, useApiManagementRef (and Async variants) for handling GET/POST/PUT/DELETE requests with built-in SSR support, validation (contract-based), reactivity, and skeleton states.
+- Reactive Utilities: ListDataRef (list management/selection/navigation), DatetimeRef (reactive date manipulation), and GeoRef/GeoIntlRef (geo-data and internationalization).
+- Global State: executeUse (Global/Provide/Local patterns) for managing singletons, useMeta (global SEO management), and various storage/browser-tab sync hooks (useCookieRef, useSessionRef, useBroadcastValueRef).
+- Render Utilities: Helper functions for VNode rendering, class/style binding (getBind, toBind), and reactive property unwrapping (getRef, executeFunctionRef).
+
+Triggers for Studying ai-types.md:
+- When encountering errors or ambiguity regarding Type constraints for API request/response contracts (`ApiDataValidation`, `ApiErrorStorageList`).
+- When defining complex component Props or custom UI structures that require specific type inference for classes, styles, or slots.
+- When implementing data lists (`ListDataRef`) or search logic that depends on strict structural compliance defined by `ListTypes` or `SearchTypes`.
+- When integrating the `dxtFunctionalPlugin` or configuring custom API/Translate instances.
+
+Integration Context: Built on top of Vue 3 and its reactivity system (Refs, Computed, EffectScope). It acts as a bridge between the `@dxtmisha/functional-basic` library and Vue, specifically handling the transformation of raw functional logic into Vue-compatible reactive objects, composables, and lifecycle-aware services.

package/ai-doc.md

@@ -0,0 +1,226 @@
+This is the main functional library for the Vue environment (@dxtmisha/functional). It contains Vue-specific utilities, composables, and reactive classes.
+
+USAGE RULES:
+1. When developing in Vue, always use this library for functionality, logic, and composables instead of `@dxtmisha/functional-basic` whenever possible.
+2. It wraps basic non-reactive logic into Vue's reactivity system. If the required function or composable exists here, it has absolute priority.
+3. Import utilities from `@dxtmisha/functional` for reactive UI behavior, composables, and state management.
+
+WORKING WITH API AND STATE (useApi / executeUse):
+A set of composables is provided for network requests: `useApiGet`, `useApiPost`, `useApiPut`, `useApiDelete`, `useApiRequest`, `useApiRef`, `useApiAsyncRef`, `useApiManagementRef`, `useApiManagementAsyncRef`.
+Strictly follow these rules for their application:
+
+1. DO NOT call these composables directly in the Vue components (SFC).
+2. Move all API configurations and `useApi*` calls into SEPARATE FILES (services/stores).
+3. Wrap the API configurations inside the `executeUse` factory (specifically: `executeUseGlobal`, `executeUseProvide`, or `executeUseLocal` from `src/functions/executeUse.ts`). This guarantees the creation of managed singletons (single access point) and prevents duplicated requests and reactive states.
+4. Perform any additional request processing (e.g., data mapping, preparing structures for skeletons before loading a form) in the same file, inside the `executeUse` callback, and return a fully prepared set of data and methods.
+   *Example of correct usage:*
+   ```ts
+   import { executeUseGlobal } from '@dxtmisha/functional';
+   import { useApiManagementRef } from '@dxtmisha/functional';
+
+   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
+       { path: (o) => `/api/users/${o.id}` },  // PUT
+       { path: (o) => `/api/users/${o.id}` }   // DELETE
+     );
+     // Logic for skeletons, additional formatting, etc., should be added here,
+     // and then return the extended object.
+   });
+   ```
+5. Within the Vue component itself, simply import and call your custom singleton composable: `const { list, loading, sendPost } = useUserManagement();`
+
+CHOOSING THE executeUse STRATEGY:
+1. `executeUseLocal` (PREFERRED):
+   - When to use: For most API requests and services.
+   - Key Features: Works "lazily" (lazy initialization) — initializes only when first called. The instance persists until the end of the session. This prevents overloading the application start with unnecessary requests.
+2. `executeUseGlobal`:
+   - When to use: When data or a service must be loaded/initialized IMMEDIATELY at application start (e.g., critical settings, SDKs).
+   - Key Features: Creates a single instance for the entire application. All global singletons are forcibly initialized via `executeUseGlobalInit()`.
+3. `executeUseProvide`:
+   - When to use: For state shared between a parent and a group of child components (e.g., tabs, complex forms with sub-components).
+   - Key Features: Uses provide/inject. The first component in the tree that calls the hook becomes the "provider", others become consumers.
+
+=============================================================================
+DEVELOPER GUIDE: USING `@dxtmisha/functional` AS A LIBRARY
+=============================================================================
+
+This section contains instructions and code guidelines for AI models on how to import and use the Vue-specific reactive classes, composables, and utility functions provided by this library in Vue 3 / Nuxt applications.
+
+---
+
+### 1. Reactive Storage & State Composables
+
+These composables bind browser storages reactively to Vue `Ref` objects, keeping them in sync.
+
+#### `useStorageRef` (localStorage)
+Reactively binds a key from `localStorage`.
+```typescript
+import { useStorageRef } from '@dxtmisha/functional';
+
+// Bind to key with optional initial default value
+const theme = useStorageRef<'light' | 'dark'>('theme_key', 'light');
+
+// Setting the value triggers an immediate update to localStorage reactively
+theme.value = 'dark';
+```
+
+#### `useSessionRef` (sessionStorage) & `useCookieRef` (Cookies)
+```typescript
+import { useSessionRef, useCookieRef } from '@dxtmisha/functional';
+
+// sessionStorage
+const step = useSessionRef<number>('form_step', 1);
+
+// CookieStorage
+const token = useCookieRef<string>('auth_token', '', { secure: true });
+```
+
+#### `useBroadcastValueRef` (Cross-Tab Synchronization)
+Synchronizes a state value reactively across multiple browser tabs under the same origin.
+```typescript
+import { useBroadcastValueRef } from '@dxtmisha/functional';
+
+// Synchronizes the value of the ref across tabs using BroadcastChannel
+const syncState = useBroadcastValueRef<string>('active_channel', 'idle');
+```
+
+#### `useHashRef` (URL Hash)
+Reactively binds Vue state to the URL hash parameters.
+```typescript
+import { useHashRef } from '@dxtmisha/functional';
+
+const hashPage = useHashRef<string>('page', 'home');
+```
+
+---
+
+### 2. Reactive Geolocation & Internationalization (`GeoRef`, `GeoIntlRef`, `GeoFlagRef`, `useTranslateRef`)
+
+Provides reactive integrations for internationalization APIs.
+
+#### `GeoRef` & `GeoIntlRef`
+```typescript
+import { GeoRef, useGeoIntlRef } from '@dxtmisha/functional';
+
+// Reactive tracking of user location details
+const currentCountry = GeoRef.getCountry(); // ComputedRef<string>
+
+// Reactive i18n formatter hook
+const intl = useGeoIntlRef();
+const formattedPrice = intl.currency(150, 'EUR'); // ComputedRef<string>
+```
+
+#### `useTranslateRef`
+Reactively loads and gets translation tokens.
+```typescript
+import { useTranslateRef } from '@dxtmisha/functional';
+
+const translations = useTranslateRef(['global.save', 'global.cancel']);
+// returns: ShallowRef<Record<string, string>> containing loaded translations
+```
+
+---
+
+### 3. SEO & Layout Utilities
+
+#### `useMeta`
+Manages page metadata reactively. Calling setters will update document headers and tags reactively.
+```typescript
+import { useMeta } from '@dxtmisha/functional';
+
+const metaManager = useMeta();
+metaManager.setTitle('My Product Page');
+metaManager.setDescription('Product details and configurations.');
+```
+
+#### `ScrollbarWidthRef`
+Tracks the scrollbar width reactively to solve layout shift issues.
+```typescript
+import { ScrollbarWidthRef } from '@dxtmisha/functional';
+
+const scrollbar = new ScrollbarWidthRef();
+const width = scrollbar.width; // Ref<number>
+const hasScroll = scrollbar.is; // ComputedRef<boolean>
+```
+
+---
+
+### 4. Advanced Reactivity Helpers
+
+#### `computedAsync`
+Creates a computed property that resolves its value asynchronously. Useful for async tasks inside computed getters.
+```typescript
+import { computedAsync } from '@dxtmisha/functional';
+
+// Performs asynchronous data lookup and reactively returns the result
+const asyncData = computedAsync(async () => {
+  return await fetchSomeData(activeId.value);
+}, 'initial_loading_value');
+```
+
+#### `computedEternity`
+Computes an asynchronous value once and caches it indefinitely unless manually refreshed.
+```typescript
+import { computedEternity } from '@dxtmisha/functional';
+
+const cachedData = computedEternity(async () => {
+  return await fetchStaticData();
+}, 'loading_state');
+```
+
+---
+
+### 5. List & Search Orchestration
+
+#### `ListDataRef`
+A powerful reactive state orchestrator for managing lists, groups, items, pagination, highlight paths, and selections.
+```typescript
+import { ListDataRef } from '@dxtmisha/functional';
+
+const items = ref([
+  { value: 'id1', label: 'First Option' },
+  { value: 'id2', label: 'Second Option' },
+]);
+const selectedId = ref('id1');
+
+const listData = new ListDataRef(items, selectedId);
+const isSelected = listData.isSelected; // ComputedRef<boolean>
+const nextItem = listData.getSelectedNext(); // returns next select item
+```
+
+#### `useSearchRef`
+Combines a source list, target fields, search query, and options to reactively search a list with built-in delay and highlight support.
+```typescript
+import { useSearchRef } from '@dxtmisha/functional';
+
+const query = ref('second');
+const { listSearch, loading, length } = useSearchRef(items, ['label'], query);
+```
+
+---
+
+### 6. DOM & Lazy Rendering
+
+#### `EventRef`
+Reactive wrapper for DOM events. Starts and stops event binding cleanly inside Vue component lifecycles (runs setup and teardown hooks automatically).
+```typescript
+import { EventRef } from '@dxtmisha/functional';
+
+// Listens reactively; auto-starts on setup and auto-stops on unmounted
+const keyListener = new EventRef(window, window, 'keydown', (event) => {
+  console.log('Key pressed', event.key);
+});
+```
+
+#### `useLazyRef`
+Reactive manager utilizing `IntersectionObserver` to defer rendering of off-screen components.
+```typescript
+import { useLazyRef } from '@dxtmisha/functional';
+
+const lazyManager = useLazyRef();
+const isVisible = lazyManager.addLazyItem(elementRef); // ShallowRef<boolean>
+```

package/{ai-types.txt → ai-types.md}

@@ -16,10 +16,6 @@ The following is the content of "exports" from package.json:
 
 // File: src/classes/design/DesignAbstract.d.ts
 export declare abstract class DesignAbstract<T extends Record<string, any>, C extends Record<string, any>> {
-    protected readonly props: T;
-    protected readonly callback?: ((event: C) => void) | undefined;
-    protected readonly event: C;
-    protected readonly changed: DesignChanged<T>;
     constructor(props: T, callback?: ((event: C) => void) | undefined, changed?: string[]);
     make(compelled?: boolean): this;
     makeCallback(compelled?: boolean): void;
@@ -35,8 +31,6 @@ export declare abstract class DesignAsyncAbstract<T extends Record<string, any>,
 
 // File: src/classes/design/DesignChanged.d.ts
 export declare class DesignChanged<T extends Record<string, any>> {
-    protected readonly props: T;
-    protected readonly watch: string[];
     constructor(props: T, watch?: string[]);
     is(name: string | string[]): boolean;
     isChanged(): boolean;
@@ -49,9 +43,6 @@ export declare class DesignComp<COMP extends ConstrComponent, P extends ConstrIt
 
 // File: src/classes/design/DesignComponents.d.ts
 export declare class DesignComponents<COMP extends ConstrComponent, P extends ConstrItem> {
-    protected readonly components: COMP;
-    protected readonly modification?: ConstrComponentMod<P> | undefined;
-    protected caching: Record<string, ComputedRef<any>>;
     constructor(components?: COMP, modification?: ConstrComponentMod<P> | undefined);
     is<K extends keyof COMP>(name: K): name is K;
     get<K extends keyof COMP>(name: K): COMP[K];
@@ -63,20 +54,6 @@ export declare class DesignComponents<COMP extends ConstrComponent, P extends Co
 
 // File: src/classes/design/DesignConstructorAbstract.d.ts
 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 readonly props: Readonly<P>;
-    protected readonly options?: ConstrOptions<COMP, EMITS, P> | undefined;
-    protected readonly name: string[];
-    protected readonly element: Ref<E | undefined, E | undefined>;
-    protected readonly refs: ToRefs<P>;
-    protected readonly components: DesignComponents<COMP, P>;
-    protected readonly emits?: ConstrEmit<EMITS>;
-    protected readonly classes?: ComputedRef<CLASSES>;
-    protected classesSub?: ComputedRef<Partial<CLASSES>>;
-    protected readonly styles?: ComputedRef<ConstrStyles>;
-    protected stylesSub?: ComputedRef<ConstrStyles>;
-    protected attrs?: ConstrItem;
-    protected slots?: SLOTS;
-    protected dataExpose?: EXPOSE;
     protected constructor(name: string, props: Readonly<P>, options?: ConstrOptions<COMP, EMITS, P> | undefined);
     protected init(): this;
     getName(): string;
@@ -91,24 +68,10 @@ export declare abstract class DesignConstructorAbstract<E extends Element, COMP
     protected abstract initClasses(): Partial<CLASSES>;
     protected abstract initStyles(): ConstrStyles;
     protected abstract initRender(): 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
 export declare class DatetimeRef {
-    protected item: Ref<NumberOrStringOrDate>;
-    protected type: Ref<GeoDate>;
-    protected code: Ref<string>;
-    protected date: Ref<Date>;
-    protected datetime: Datetime;
-    protected year: Ref<number, number>;
-    protected month: Ref<number, number>;
-    protected day: Ref<number, number>;
-    protected hour: Ref<number, number>;
-    protected minute: Ref<number, number>;
-    protected second: Ref<number, number>;
     constructor(date: RefOrNormal<NumberOrStringOrDate>, type?: RefOrNormal<GeoDate>, code?: RefOrNormal<string>);
     getItem(): Ref<NumberOrStringOrDate>;
     getDate(): Ref<Date>;
@@ -138,7 +101,6 @@ export declare class EventRef<E extends ElementOrWindow, O extends Event, D exte
 
 // File: src/classes/ref/GeoFlagRef.d.ts
 export declare class GeoFlagRef {
-    protected flag: ComputedRef<GeoFlag>;
     constructor(code?: RefOrNormal<string | undefined>);
     getCode(): string;
     get(code?: RefOrNormal<string>): ComputedRef<GeoFlagItem | undefined>;
@@ -181,25 +143,15 @@ export declare class GeoRef {
     static getLanguage(): ComputedRef<string>;
     static getStandard(): ComputedRef<string>;
     static getFirstDay(): ComputedRef<string>;
+    static getLocation(): ComputedRef<string>;
+    static getLocationCountry(): ComputedRef<string>;
+    static getLocationLanguage(): ComputedRef<string>;
     static set(code: string): void;
     static setValueDefault(code?: string | (() => string)): void;
 }
 
 // File: src/classes/ref/ListDataRef.d.ts
 export declare class ListDataRef {
-    protected readonly list: RefOrNormal<ListListInput | undefined>;
-    protected readonly focus?: RefType<ListSelectedItem | undefined> | undefined;
-    protected readonly highlight?: RefType<string | undefined> | undefined;
-    protected readonly highlightLengthStart?: RefType<number | undefined> | undefined;
-    protected readonly filterMode?: RefType<boolean | undefined> | undefined;
-    protected readonly selected?: RefType<ListSelectedList | undefined> | undefined;
-    protected readonly keyValue?: RefType<string | undefined> | undefined;
-    protected readonly keyLabel?: RefType<string | undefined> | undefined;
-    protected readonly lite?: RefType<number | undefined> | undefined;
-    protected readonly min: RefOrNormal<number | string | undefined>;
-    protected readonly max: RefOrNormal<number | string | undefined>;
-    protected readonly parent?: string | undefined;
-    protected subList: Record<any, 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>;
     readonly liteData: ComputedRef<ListList>;
@@ -267,129 +219,34 @@ export declare function useApiAsyncRef<R, T = R>(path?: RefOrNormal<string | und
 
 // File: src/composables/ref/useApiDelete.d.ts
 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>;
-};
+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
 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>;
-};
+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
-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>;
-    list: ComputedRef<SearchFormatList<ItemFormatters, Columns>>;
-    readonly data: ComputedRef< ApiData<Return> | undefined>;
-    errorItem: ComputedRef< ApiErrorItem | undefined>;
-    readonly length: ComputedRef<number>;
-    lengthData: ComputedRef<number>;
-    starting: ComputedRef<boolean>;
-    reading: Ref<boolean, boolean>;
-    loading: Ref<boolean, boolean>;
-    loadingSearch: Ref<boolean, boolean> | undefined;
-    loadingPost: Ref<boolean, boolean> | undefined;
-    loadingPut: Ref<boolean, boolean> | undefined;
-    loadingDelete: Ref<boolean, boolean> | undefined;
-    isSearch: ComputedRef<boolean> | undefined;
-    search: Ref<string>;
-    init: () => void;
-    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>;
-};
+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>; list: ComputedRef<SearchFormatList<ItemFormatters, Columns>>; readonly data: ComputedRef< ApiData<Return> | undefined>; errorItem: ComputedRef< ApiErrorItem | undefined>; readonly length: ComputedRef<number>; lengthData: ComputedRef<number>; starting: ComputedRef<boolean>; reading: Ref<boolean, boolean>; loading: Ref<boolean, boolean>; loadingSearch: Ref<boolean, boolean> | undefined; loadingPost: Ref<boolean, boolean> | undefined; loadingPut: Ref<boolean, boolean> | undefined; loadingDelete: Ref<boolean, boolean> | undefined; isSearch: ComputedRef<boolean> | undefined; search: Ref<string>; init: () => void; 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>; };
 
 // File: src/composables/ref/useApiManagementRef.d.ts
-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>;
-    list: ComputedRef<SearchFormatList<ItemFormatters, Columns>>;
-    readonly data: ComputedRef<ApiData<Return> | undefined>;
-    errorItem: ComputedRef< ApiErrorItem | undefined>;
-    readonly length: ComputedRef<number>;
-    lengthData: ComputedRef<number>;
-    starting: ComputedRef<boolean>;
-    reading: Ref<boolean, boolean>;
-    loading: Ref<boolean, boolean>;
-    loadingSearch: Ref<boolean, boolean> | undefined;
-    loadingPost: Ref<boolean, boolean> | undefined;
-    loadingPut: Ref<boolean, boolean> | undefined;
-    loadingDelete: Ref<boolean, boolean> | undefined;
-    isSearch: ComputedRef<boolean> | undefined;
-    search: Ref<string>;
-    init: () => void;
-    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>;
-};
+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>; list: ComputedRef<SearchFormatList<ItemFormatters, Columns>>; readonly data: ComputedRef<ApiData<Return> | undefined>; errorItem: ComputedRef< ApiErrorItem | undefined>; readonly length: ComputedRef<number>; lengthData: ComputedRef<number>; starting: ComputedRef<boolean>; reading: Ref<boolean, boolean>; loading: Ref<boolean, boolean>; loadingSearch: Ref<boolean, boolean> | undefined; loadingPost: Ref<boolean, boolean> | undefined; loadingPut: Ref<boolean, boolean> | undefined; loadingDelete: Ref<boolean, boolean> | undefined; isSearch: ComputedRef<boolean> | undefined; search: Ref<string>; init: () => void; 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>; };
 
 // File: src/composables/ref/useApiPost.d.ts
 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>;
-};
+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
 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>;
-};
+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
-export interface UseApiRef<R> {
-    data: ComputedRef<ApiData<R> | undefined>;
-    item: Ref<ApiData<R> | undefined>;
-    errorItem: ComputedRef<ApiErrorItem | undefined>;
-    isResponseContractValid: ComputedRef<boolean>;
-    responseValidationResult: ComputedRef<ApiDataValidation | undefined>;
-    length: ComputedRef<number>;
-    starting: ComputedRef<boolean>;
-    loading: Ref<boolean>;
-    reading: Ref<boolean>;
-    isStarting(): boolean;
-    isLoading(): boolean;
-    isReading(): boolean;
-    getItem(): ApiData<R> | undefined;
-    init(): void;
-    initSsr(): void;
-    reset(): Promise<void>;
-    stop(): void;
-    abort(): void;
-}
+export interface UseApiRef<R> { data: ComputedRef<ApiData<R> | undefined>; item: Ref<ApiData<R> | undefined>; errorItem: ComputedRef<ApiErrorItem | undefined>; isResponseContractValid: ComputedRef<boolean>; responseValidationResult: ComputedRef<ApiDataValidation | undefined>; length: ComputedRef<number>; starting: ComputedRef<boolean>; loading: Ref<boolean>; reading: Ref<boolean>; isStarting(): boolean; isLoading(): boolean; isReading(): boolean; getItem(): ApiData<R> | undefined; init(): void; initSsr(): void; reset(): Promise<void>; stop(): void; abort(): void; }
 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
-export interface UseApiRequestSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> {
-    path?: RefOrNormal<string | undefined>;
-    method?: ApiMethodItem;
-    action?: (data: Return | undefined) => Promise<void> | void;
-    transformation?: (data: T) => Return;
-    validateRequestContract?: (data: Request) => ApiDataValidation & Return;
-    validateResponseContract?: (data: T) => ApiDataValidation & Return;
-    errorContract?: ApiErrorStorageList;
-    toData?: boolean;
-    options?: ApiOptions;
-    apiInstance?: ApiInstance;
-}
-export declare function useApiRequest<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>({ path, method, action, transformation, validateRequestContract, validateResponseContract, errorContract, toData, options, apiInstance }: UseApiRequestSetup<T, Request, Return>): {
-    loading: Ref<boolean, boolean>;
-    send(request?: Request): Promise<Return | undefined>;
-};
+export interface UseApiRequestSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> { path?: RefOrNormal<string | undefined>; method?: ApiMethodItem; action?: (data: Return | undefined) => Promise<void> | void; transformation?: (data: T) => Return; validateRequestContract?: (data: Request) => ApiDataValidation & Return; validateResponseContract?: (data: T) => ApiDataValidation & Return; errorContract?: ApiErrorStorageList; toData?: boolean; options?: ApiOptions; apiInstance?: ApiInstance; }
+export declare function useApiRequest<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>({ path, method, action, transformation, validateRequestContract, validateResponseContract, errorContract, toData, options, apiInstance }: UseApiRequestSetup<T, Request, Return>): { loading: Ref<boolean, boolean>; send(request?: Request): Promise<Return | undefined>; };
 
 // File: src/composables/ref/useBroadcastValueRef.d.ts
 export declare function useBroadcastValueRef<T>(name: string, defaultValue?: T | string | (() => (T | string))): Ref<T | string | undefined>;
@@ -398,10 +255,7 @@ export declare function useBroadcastValueRef<T>(name: string, defaultValue?: T |
 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
-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>;
-};
+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
 export declare function useGeoIntlRef(): GeoIntlRef;
@@ -422,7 +276,10 @@ export declare const useLazyRef: (options?: IntersectionObserverInit) => { inter
 export declare function useLoadingRef(): ShallowRef<boolean, boolean>;
 
 // File: src/composables/ref/useMeta.d.ts
-export declare const useMeta: () => Readonly<{ meta: typeof MetaStatic; title: Ref<string, string>; keyword: Ref<string, string>; description: Ref<string, string>; author: Ref<string, string>; image: Ref<string, string>; canonical: Ref<string, string>; robots: Ref<MetaRobots, MetaRobots>; siteName: Ref<string, string>; getHtmlMeta: () => string; sync: () => void; update: () => void; updateSsr: () => void; setTitle: (value: string) => void; setKeywords: (value: string) => void; setDescription: (value: string) => void; setAuthor: (value: string) => void; setImage: (value: string) => void; setCanonical: (value: string) => void; setRobots: (value: MetaRobots) => void; setSiteName: (value: string) => void; setSuffix: (suffix: string) => typeof MetaStatic; } & { init(): Readonly<any>; destroyExecute?(): void; }>;
+export declare const useMeta: () => Readonly<{ meta: typeof MetaStatic; title: Ref<string, string>; keyword: Ref<string, string>; description: Ref<string, string>; author: Ref<string, string>; image: Ref<string, string>; canonical: Ref<string, string>; robots: Ref<MetaRobots, MetaRobots>; siteName: Ref<string, string>; getHtmlMeta: () => string; sync: () => void; update: () => void; updateSsr: () => void; setTitle: (value: string) => void; setKeywords: (value: string) => void; setDescription: (value: string) => void; setAuthor: (value: string) => void; setImage: (value: string) => void; setCanonical: (value: string) => void; setRobots: (value: MetaRobots) => void; setSiteName: (value: string) => void; setSuffix: (suffix: string) => typeof MetaStatic; } & { init(): any; destroyExecute?(): void; }>;
+
+// File: src/composables/ref/useQueryRef.d.ts
+export declare function useQueryRef<T>(name: string, defaultValue?: T | (() => T)): ShallowRef<T>;
 
 // File: src/composables/ref/useRouterList.d.ts
 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>; label: ComputedRef<NumberOrString>; list: ComputedRef<ConstrBind<T>[]>; to: (name?: string) => void; toMain(): void; };
@@ -466,9 +323,9 @@ export declare const dxtFunctionalPlugin: Plugin;
 export declare enum ExecuteUseType { global = "global", provide = "provide", local = "local" }
 export type ExecuteUseReturn<R> = Readonly<R & { init(): Readonly<R>; destroyExecute?(): void; }>;
 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<any>) | (() => Readonly<any>);
-export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<any>) | (() => Readonly<any>);
-export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<any>) | (() => Readonly<any>);
+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; }>);
 export declare function executeUseGlobalInit(): void;
 
 // File: src/functions/getInject.d.ts
@@ -513,6 +370,73 @@ export declare function toBind<R extends ItemList = ItemList>(extra: ItemList, v
 // File: src/functions/toBinds.d.ts
 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/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/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
 export type ApiOptions = ApiMethodItem | RefOrNormal<ApiFetch>;
 export type ApiManagementValue = ApiDefaultValue | ApiDefaultValue[];