@dxtmisha/functional 1.13.1 → 1.13.3

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.13.2] - 2026-06-05
+
+### Changed / Improved
+- **Maintenance**: Version bumped to `1.13.2` to synchronize package updates across the workspace.
+
+## [1.13.1] - 2026-06-02
+
+### Changed / Improved
+- **Maintenance**: Version bumped to `1.13.1` to align with monorepo release updates.
+
+## [1.13.0] - 2026-05-29
+
+### Added
+- **refTypes**: Added `RefOrNormalOrFunction` union type representing references, normal values, or functions returning them.
+- **Functions**: Introduced `executeFunctionRef` utility function to safely execute functions or unwrap reference values in a single call.
+
 ## [1.12.3] - 2026-05-25
 
 ### Changed / Improved

package/ai-description.txt

@@ -1,5 +1,10 @@
-This library is a technical SDK for Vue 3 that facilitates the construction of design systems and complex application states through reactive abstractions. Its primary function is to provide a standardized architecture for API orchestration, design component construction, and reactive utility management. It extends low-level logic from @dxtmisha/functional-basic into the Vue reactivity ecosystem.
+Core Purpose: This library is a comprehensive Vue 3 framework for reactive application architecture. It provides high-level abstractions for API orchestration (fetching, mutation, SSR, schema validation), state management (singletons, reactive storage, session/cookie handling), component design (base classes for rendering and lifecycle management), and localization/internationalization (geo-data, formatting, date management).
 
-Study this library when implementing robust API integration layers that require built-in SSR support, response contract validation, and automated mutation handling (POST/PUT/DELETE). It is indispensable for developing design systems that need base classes for tracking property changes and rendering dynamic component trees. Use its API for reactive localization (i18n), geographic data handling, SEO meta tag synchronization, and implementing singleton service patterns via provide/inject or global scopes.
+Usage Scenarios: Study this API when building complex, data-intensive Vue 3 applications requiring:
+1. Centralized, reactive API management (GET/POST/PUT/DELETE) with built-in SSR support, caching, and automatic response contract validation.
+2. Unified component architecture using base design classes for consistent styling, rendering, and lifecycle event management.
+3. Complex list handling, client-side searching, and advanced data formatting (Intl, currency, dates).
+4. Cross-tab communication or persistent reactive state storage (localStorage, sessionStorage, cookies).
+5. Global service configuration (meta tags, translation, icons, API settings) via Vue plugins.
 
-The library integrates deeply with the Vue 3 composition API and vue-router. It operates as a Vue plugin, managing global services for icons, translations, and error handling. It bridges the gap between pure functional utilities and reactive UI requirements, specifically targeting environments where SSR consistency and strict data validation are priorities.
+Integration Context: The library acts as a core infrastructure layer. It is built on top of Vue 3's Composition API and `vue-router`. It relies heavily on `@dxtmisha/functional-basic` for underlying logic. It should be treated as the primary service and utility layer that replaces manual store management (like Pinia) and repetitive API/lifecycle boilerplate by providing standardized patterns (e.g., `executeUse` for singletons) for shared state and service orchestration.

package/ai-types.txt

@@ -15,201 +15,91 @@ The following is the content of "exports" from package.json:
 }
 
 // File: src/classes/design/DesignAbstract.d.ts
-/**
- * Base constructor class.
- */
 export declare abstract class DesignAbstract<T extends Record<string, any>, C extends Record<string, any>> {
-    /**
-     * Constructor
-     * @param props base data
-     * @param callback change callback
-     * @param changed tracking data
-     */
     constructor(props: T, callback?: ((event: C) => void) | undefined, changed?: string[]);
-    /**
-     * Executes callback.
-     * @param compelled forces update
-     */
     make(compelled?: boolean): this;
-    /**
-     * Executes callback.
-     * @param compelled forces update
-     */
     makeCallback(compelled?: boolean): void;
-    /**
-     * Called when input values change.
-     */
-    protected abstract initEvent(): void;
 }
+
 // File: src/classes/design/DesignAsyncAbstract.d.ts
-/**
- * Base constructor class.
- */
+import { DesignAbstract } from './DesignAbstract';
 export declare abstract class DesignAsyncAbstract<T extends Record<string, any>, C extends Record<string, any>> extends DesignAbstract<T, C> {
-    /**
-     * Executes callback.
-     * @param compelled forces update
-     */
     make(compelled?: boolean): this;
-    /**
-     * Executes callback.
-     * @param compelled forces update
-     */
     makeCallback(compelled?: boolean): Promise<void>;
-    /**
-     * Called when input values change.
-     */
-    protected abstract initEvent(): Promise<void>;
 }
+
 // File: src/classes/design/DesignChanged.d.ts
-/**
- * Checks edited values.
- */
 export declare class DesignChanged<T extends Record<string, any>> {
-    /**
-     * Constructor
-     * @param props base data
-     * @param watch tracking data
-     */
     constructor(props: T, watch?: string[]);
-    /**
-     * Checks if updated.
-     * @param name property name
-     */
     is(name: string | string[]): boolean;
-    /**
-     * Checks for changes.
-     */
     isChanged(): boolean;
-    /**
-     * Updates values.
-     */
     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
-/**
- * Class for connected components.
- */
+import { ComputedRef, VNode } from 'vue';
+import { RawChildren, RawSlots } from '../../types/refTypes';
+import { ConstrComponent, ConstrComponentMod, ConstrItem } from '../../types/constructorTypes';
 export declare class DesignComponents<COMP extends ConstrComponent, P extends ConstrItem> {
-    /**
-     * Constructor
-     * @param components list of components
-     * @param modification modification data
-     */
+    protected caching: Record<string, ComputedRef<any>>;
     constructor(components?: COMP, modification?: ConstrComponentMod<P> | undefined);
-    /**
-     * Checks component presence.
-     * @param name component name
-     */
     is<K extends keyof COMP>(name: K): name is K;
-    /**
-     * Gets component object.
-     * @param name component name
-     */
     get<K extends keyof COMP>(name: K): COMP[K];
-    /**
-     * Returns modified input data.
-     * @param index name
-     * @param props basic data
-     */
     getModification<K extends keyof P>(index?: K & string | string, props?: P[K] | Record<string, any>): Record<string, any> | undefined;
-    /**
-     * Renders component as array.
-     * @param name component name
-     * @param props component props
-     * @param children sub-elements
-     * @param index key name
-     */
     render<K extends keyof COMP, PK extends keyof P>(name: K & string, props?: P[PK] & ConstrItem | ConstrItem, children?: RawChildren | RawSlots, index?: PK & string | string): VNode[];
-    /**
-     * Renders single component.
-     * @param name component name
-     * @param props component props
-     * @param children sub-elements
-     * @param index key name
-     */
     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;
-    /**
-     * Adds rendered component to array.
-     * @param item target array
-     * @param name component name
-     * @param props component props
-     * @param children sub-elements
-     * @param index key name
-     */
     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
-/**
- * Class for functional components.
- */
+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> {
-    /**
-     * Gets class name.
-     */
+    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;
-    /**
-     * Gets design name.
-     */
     getDesign(): string;
-    /**
-     * Gets subclass name.
-     * @param name class levels
-     */
     getSubClass(name: string | string[]): string;
-    /**
-     * Gets status class name.
-     * @param name class levels
-     */
     getStatusClass(name: string | string[]): string;
-    /**
-     * Gets style property name.
-     * @param name class levels
-     */
     getStyle(name: string | string[]): string;
-    /**
-     * Gets attributes.
-     */
     getAttrs(): ConstrItem;
-    /**
-     * External variables list.
-     */
     expose(): ConstrExpose<E, EXPOSE>;
-    /**
-     * Render method.
-     */
     render(): () => VNode | (VNode | any)[] | undefined;
-    /**
-     * Initializes expose properties.
-     */
     protected abstract initExpose(): EXPOSE;
-    /**
-     * Refines class list.
-     */
     protected abstract initClasses(): Partial<CLASSES>;
-    /**
-     * Refines style list.
-     */
     protected abstract initStyles(): ConstrStyles;
-    /**
-     * Rendering logic.
-     */
     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
-/**
- * Date utility class.
- */
+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
-     * @param date input date
-     * @param type date format
-     * @param code locale code
-     */
     constructor(date: RefOrNormal<NumberOrStringOrDate>, type?: RefOrNormal<GeoDate>, code?: RefOrNormal<string>);
     getItem(): Ref<NumberOrStringOrDate>;
     getDate(): Ref<Date>;
@@ -223,55 +113,39 @@ export declare class DatetimeRef {
     getMinute(): ComputedRef<number>;
     getSecond(): ComputedRef<number>;
     getMaxDay(): ComputedRef<number>;
-    /**
-     * Locale formatting.
-     * @param type format type
-     * @param styleOptions month representation
-     */
     locale(type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions): ComputedRef<string>;
-    /**
-     * Standard output.
-     * @param timeZone include timezone
-     */
     standard(timeZone?: boolean): ComputedRef<string>;
 }
+
 // File: src/classes/ref/EffectScopeGlobal.d.ts
-/**
- * Global effect scope.
- */
 export declare class EffectScopeGlobal {
-    /**
-     * Run function in global scope.
-     */
     static run<T>(fn: () => T): T | undefined;
 }
+
 // File: src/classes/ref/EventRef.d.ts
-/**
- * Event handling class (Ref).
- */
+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
-/**
- * Flag utility class.
- */
+import { ComputedRef } from 'vue';
+import { GeoFlag, GeoFlagItem, GeoFlagNational } from '@dxtmisha/functional-basic';
+import { RefOrNormal } from '../../types/refTypes';
 export declare class GeoFlagRef {
-    /**
-     * Constructor
-     * @param code locale code
-     */
-    constructor(code?: RefOrNormal<string>);
-    getCode(): Ref<string>;
-    get(code?: string): ComputedRef<GeoFlagItem | undefined>;
-    getFlag(code?: string): ComputedRef<string | undefined>;
-    getList(codes?: string[]): ComputedRef<GeoFlagItem[]>;
-    getNational(codes?: string[]): ComputedRef<GeoFlagNational[]>;
+    constructor(code?: RefOrNormal<string | undefined>);
+    getCode(): string;
+    get(code?: RefOrNormal<string>): ComputedRef<GeoFlagItem | undefined>;
+    getFlag(code?: RefOrNormal<string>): ComputedRef<string | undefined>;
+    getList(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagItem[]>;
+    getNational(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
 }
+
 // File: src/classes/ref/GeoIntlRef.d.ts
-/**
- * Formatting for numbers and dates.
- */
+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>;
@@ -297,26 +171,23 @@ 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
-/**
- * Geographic data class.
- */
+import { ComputedRef, Ref } from 'vue';
+import { GeoItemFull } from '@dxtmisha/functional-basic';
 export declare class GeoRef {
     static get(): Ref<GeoItemFull>;
     static getCountry(): ComputedRef<string>;
     static getLanguage(): ComputedRef<string>;
     static getStandard(): ComputedRef<string>;
     static getFirstDay(): ComputedRef<string>;
-    /**
-     * Changes data by code.
-     * @param code locale/country code
-     */
     static set(code: string): void;
 }
+
 // File: src/classes/ref/ListDataRef.d.ts
-/**
- * List data management.
- */
+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>;
@@ -354,19 +225,16 @@ 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
-/**
- * Router management.
- */
+import { RouteLocationRaw, Router } from 'vue-router';
+import { ConstrHrefProps } from '../../types/constructorTypes';
 export declare class RouterItemRef {
     static get(): Router;
     static getLink(name: string, params?: any, query?: any): string | undefined;
@@ -376,57 +244,56 @@ export declare class RouterItemRef {
     static setOneTime(router: Router): void;
     static rawToHref(to?: string | RouteLocationRaw): ConstrHrefProps;
 }
+
 // File: src/classes/ref/ScrollbarWidthRef.d.ts
-/**
- * Reactive scroll width.
- */
+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
-/**
- * Async API composable with SSR support.
- * Use for server-side pre-fetching.
- * @example
- * ```typescript
- * const { data, loading } = useApiAsyncRef('/users/1', { method: 'GET' })
- * ```
- */
+import { ApiInstance, ApiData, ApiDataValidation, ApiErrorStorageList } from '@dxtmisha/functional-basic';
+import { UseApiRef } from './useApiRef';
+import { RefOrNormal, RefType } from '../../types/refTypes';
+import { ApiOptions } from '../../types/apiTypes';
 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'> {
 }
-/**
- * API DELETE request.
- */
 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'> {
 }
-/**
- * API GET request.
- */
 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
-/**
- * Async API management with SSR support.
- */
+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>;
@@ -442,25 +309,22 @@ 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
-/**
- * Orchestrates API loading, formatting, searching, and mutations.
- * @note Pair with `executeUse` for centralized state.
- * @remarks Recommended for display values; not technical IDs.
- * @example
- * const products = useApiManagementRef({ path: '/api/v1/products' }, { price: (v) => `${v} USD` });
- */
+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';
 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>;
@@ -480,27 +344,34 @@ 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'> {
 }
-/**
- * API POST request wrapper.
- */
 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'> {
 }
-/**
- * API PUT request wrapper.
- */
 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>;
@@ -521,16 +392,14 @@ export interface UseApiRef<R> {
     stop(): void;
     abort(): void;
 }
-/**
- * API request composable handling SSR, reactivity, and validation.
- * @example
- * ```typescript
- * const { data, loading } = useApiRef('/users/1', { method: 'GET' })
- * ```
- */
 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;
@@ -543,81 +412,61 @@ export interface UseApiRequestSetup<T, Request extends ApiFetch['request'] = Api
     options?: ApiOptions;
     apiInstance?: ApiInstance;
 }
-/**
- * Core API request handler.
- */
 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
-type BroadcastValueItem<T> = T | string | undefined;
-/**
- * Reactive data sync between tabs.
- */
-export declare function useBroadcastValueRef<T>(name: string, defaultValue?: T | string | (() => (T | string))): Ref<BroadcastValueItem<T>>;
+import { Ref } from 'vue';
+export declare function useBroadcastValueRef<T>(name: string, defaultValue?: T | string | (() => (T | string))): Ref<T | string | undefined>;
+
 // File: src/composables/ref/useCookieRef.d.ts
-/**
- * Reactive cookie management.
- */
+import { Ref } from 'vue';
+import { CookieOptions } from '@dxtmisha/functional-basic';
 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
-/**
- * Reactive list formatting.
- */
+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
-/**
- * Returns data formatting class.
- */
+import { GeoIntlRef } from '../../classes/ref/GeoIntlRef';
 export declare function useGeoIntlRef(): GeoIntlRef;
+
 // File: src/composables/ref/useHashRef.d.ts
-/**
- * Reactive hash management.
- */
+import { ShallowRef } from 'vue';
 export declare function useHashRef<T>(name: string, defaultValue?: T | (() => T)): ShallowRef<T>;
+
 // File: src/composables/ref/useLazyItemByMarginRef.d.ts
-export type LazyItemByMargin = {
-    rootMargin: string;
-    item: any;
-};
-/**
- * Tracks element screen appearance by margin.
- */
+import { RefType } from '../../types/refTypes';
 export declare const useLazyItemByMarginRef: (element: RefType<HTMLElement | undefined>, rootMargin: string) => {
     lazyItemStatus: any;
     readonly lazyItem: any;
 };
+
 // File: src/composables/ref/useLazyRef.d.ts
-export type LazyItem = {
-    status: ShallowRef<boolean>;
-    ratio: ShallowRef<number>;
-    entry: ShallowRef<IntersectionObserverEntry | undefined>;
-    stopWatch: () => void;
-};
-export type LazyList = Record<string, LazyItem>;
-/**
- * Tracks element screen appearance.
- */
+import { Ref, ShallowRef } from 'vue';
 export declare const useLazyRef: (options?: IntersectionObserverInit) => {
     intersectionObserver: IntersectionObserver | undefined;
-    getItem(element: HTMLElement): LazyItem;
+    getItem(element: HTMLElement): any;
     addLazyItem(element: Ref<HTMLElement | undefined>): ShallowRef<boolean, boolean>;
     removeLazyItem: (element?: HTMLElement) => void;
     disconnectLazy: () => void | undefined;
 };
+
 // File: src/composables/ref/useLoadingRef.d.ts
-/**
- * Returns loading status.
- */
+import { ShallowRef } from 'vue';
 export declare function useLoadingRef(): ShallowRef<boolean, boolean>;
+
 // File: src/composables/ref/useMeta.d.ts
-/**
- * Meta tags management with DOM sync.
- */
+import { MetaRobots, MetaStatic } from '@dxtmisha/functional-basic';
+import { Ref } from 'vue';
 export declare const useMeta: () => Readonly<{
     meta: typeof MetaStatic;
     title: Ref<string, string>;
@@ -641,7 +490,7 @@ export declare const useMeta: () => Readonly<{
     setRobots: (value: MetaRobots) => void;
     setSiteName: (value: string) => void;
     setSuffix: (suffix: string) => typeof MetaStatic;
-} & {
+}> & {
     init(): Readonly<{
         meta: typeof MetaStatic;
         title: Ref<string, string>;
@@ -668,10 +517,13 @@ export declare const useMeta: () => Readonly<{
     }>;
     destroyExecute?(): void;
 }>;
+
 // File: src/composables/ref/useRouterList.d.ts
-/**
- * Router link list management.
- */
+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>;
@@ -680,10 +532,11 @@ export declare const useRouterList: <T extends ListDataBasic>(list: RefType<Cons
     to: (name?: string) => void;
     toMain(): void;
 };
+
 // File: src/composables/ref/useSearchRef.d.ts
-/**
- * Search logic handler.
- */
+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): {
     isSearch: ComputedRef<boolean>;
     search: Ref<string, string>;
@@ -691,60 +544,52 @@ export declare function useSearchRef<T extends SearchItem, K extends SearchColum
     listSearch: ComputedRef<SearchFormatList<T, K>>;
     length: ComputedRef<number>;
 };
+
 // File: src/composables/ref/useSearchValueRef.d.ts
-/**
- * Search value state and delay handler.
- */
+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
-/**
- * Reactive session storage management.
- */
+import { Ref } from 'vue';
 export declare function useSessionRef<T>(name: string, defaultValue?: T | (() => T)): Ref<T | undefined>;
+
 // File: src/composables/ref/useStorageRef.d.ts
-/**
- * Reactive local storage management.
- */
+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
-/**
- * Reactive translation getter.
- * Use `as const` for key inference.
- * @example
- * const translations = useTranslateRef(['home.title'] as const);
- */
+import { ShallowRef } from 'vue';
+import { TranslateInstance, TranslateList } from '@dxtmisha/functional-basic';
 export declare function useTranslateRef<T extends (string | string[])[]>(names: T, translateInstance?: TranslateInstance): ShallowRef<TranslateList<T>>;
-/**
- * useTranslateRef shorthand.
- */
 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
-/**
- * Async computed property.
- */
+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
-/**
- * Computed property dependent on current language.
- */
+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
-/**
- * On-demand cached computed property.
- */
+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
-/**
- * Functional plugin options.
- */
+import { Plugin } from 'vue';
+import { ApiConfig, ErrorCenterCauseList, ErrorCenterHandlerList, IconsConfig, TranslateConfig } from '@dxtmisha/functional-basic';
+import { Router } from 'vue-router';
 export interface FunctionalPluginOptions {
     api?: ApiConfig;
     translate?: TranslateConfig;
@@ -754,130 +599,91 @@ export interface FunctionalPluginOptions {
     errorCauses?: ErrorCenterCauseList;
     errorHandlers?: ErrorCenterHandlerList;
 }
-/**
- * Vue plugin for services initialization.
- */
 export declare const dxtFunctionalPlugin: Plugin;
+
 // File: src/functions/executeUse.d.ts
-/**
- * Singleton initialization strategies.
- */
 export declare enum ExecuteUseType {
     global = "global",
     provide = "provide",
     local = "local"
 }
-/**
- * Managed singleton return type.
- */
 export type ExecuteUseReturn<R> = Readonly<R & {
     init(): Readonly<R>;
     destroyExecute?(): void;
 }>;
-/**
- * Creates a managed singleton.
- * @remarks
- * Useful for API services, resource optimization, and shared state.
- * @example
- * export const useUserApi = executeUseGlobal(() => useApiGet('/api/user'));
- */
 export declare function executeUse<R, O extends any[], RI extends ExecuteUseReturn<R> = ExecuteUseReturn<R>>(callback: (...args: O) => R, type?: ExecuteUseType): ((...args: O) => RI) | (() => RI);
-/**
- * Global singleton.
- */
-export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<R & {
-    init(): Readonly<R>;
-    destroyExecute?(): void;
-}>) | (() => Readonly<R & {
-    init(): Readonly<R>;
-    destroyExecute?(): void;
-}>);
-/**
- * Component-scoped singleton.
- */
-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;
-}>);
-/**
- * Local singleton.
- */
-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 executeUseGlobal<R>(callback: () => R): any;
+export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): any;
+export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): any;
 export declare function executeUseGlobalInit(): void;
+
 // File: src/functions/getInject.d.ts
-/**
- * Get injected value.
- */
 export declare function getInject<T>(name: string): T | undefined;
+
 // File: src/functions/getOptions.d.ts
-/**
- * Request options getter.
- */
+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
-/**
- * API error item getter.
- */
+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
-/**
- * Generates subcomponent props.
- */
+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
-/**
- * Returns raw value from Ref or normal variable.
- */
+import { RefOrNormal } from '../../types/refTypes';
 export declare function getRef<T>(item: RefOrNormal<T>): T;
+
 // File: src/functions/ref/render.d.ts
-/**
- * Cached render data.
- */
+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
-/**
- * Updates Ref value.
- */
+import { Ref } from 'vue';
 export declare function setRef<T>(item: Ref<T>, value: T): void;
+
 // File: src/functions/ref/toRefItem.d.ts
-/**
- * Wraps value in Ref if not reactive.
- */
+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
-/**
- * Generates subcomponent props.
- */
+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
-/**
- * Gets class name from property.
- */
+import { ItemList } from '@dxtmisha/functional-basic';
 export declare function getClassName<T extends ItemList>(props?: T): string | undefined;
+
 // File: src/functions/render/getIndexForRender.d.ts
-/**
- * Generates render key.
- */
+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
-/**
- * Merges props including classes and styles.
- */
+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
-/**
- * Merges multiple props objects.
- */
+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';
@@ -926,6 +732,7 @@ 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';
@@ -942,16 +749,13 @@ export * from './types/constructorTypes';
 export * from './types/listTypes';
 export * from './types/refTypes';
 export * from './types/searchTypes';
+
 // File: src/types/apiTypes.d.ts
-/** Options for api requests */
+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>;
-/**
- * Base API management values.
- */
 export type ApiManagementValue = ApiDefaultValue | ApiDefaultValue[];
-/**
- * Main GET config for API management.
- */
 export type ApiManagementGet<Return extends ApiManagementValue, Type extends ApiManagementValue = Return> = {
     path?: RefOrNormal<string | undefined>;
     options?: ApiOptions;
@@ -964,17 +768,11 @@ export type ApiManagementGet<Return extends ApiManagementValue, Type extends Api
     unmounted?: boolean;
     skeleton?: () => Return;
 };
-/**
- * Client-side search config.
- */
 export type ApiManagementSearch<T extends SearchItem, K extends SearchColumns<T>> = {
     columns: K;
     value?: Ref<string>;
     options?: SearchOptions;
 };
-/**
- * Mutation request config.
- */
 export type ApiManagementRequest<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> = {
     path?: RefOrNormal<string | undefined>;
     action?: (data: Return | undefined) => Promise<void> | void;
@@ -985,55 +783,25 @@ export type ApiManagementRequest<T, Request extends ApiFetch['request'] = ApiFet
     toData?: boolean;
     options?: ApiOptions;
 };
+
 // File: src/types/constructorTypes.d.ts
-/** Generic record for constructor items */
+import { Ref, PropType, ComputedRef } from 'vue';
+import { Undefined } from '@dxtmisha/functional-basic';
+import { RefOrNormal, RefType } from './refTypes';
 export type ConstrItem = Record<string, any>;
-/** Constructor value wrapper */
-export type ConstrValue<T = any> = {
-    value?: T;
-};
-/** Generic record for components */
+export type ConstrValue<T = any> = { value?: T; };
 export type ConstrComponent = Record<string, any>;
-/**
- * Component modification type.
- */
-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>;
-};
-/** Utility type to convert union to intersection */
+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;
-/** Extract emit item */
 export type ConstrEmitItem<T extends ConstrItem> = T[keyof T];
-/**
- * Constructor emit signatures.
- */
-export type ConstrEmit<T extends ConstrItem = ConstrItem> = UnionToIntersection<ConstrEmitItem<{
-    [K in keyof T]: (evt: K, ...args: T[K]) => void;
-}>>;
-/** Object type for CSS classes */
+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>;
-/**
- * Constructor class formats.
- */
 export type ConstrClass = string | (string | ConstrClass | Undefined)[] | ConstrClassObject;
-/** Map class names to definitions */
 export type ConstrClassList = Record<string, ConstrClass>;
-/** Constructor classes structure */
-export type ConstrClasses = {
-    main: ConstrClass;
-} & ConstrClassList;
-/** Individual style property type */
+export type ConstrClasses = { main: ConstrClass; } & ConstrClassList;
 export type ConstrStylesItem = string | null;
-/**
- * Constructor styles structure.
- */
 export type ConstrStyles = Record<string, ConstrStylesItem> | ConstrStyles[];
-/**
- * Constructor options.
- */
 export type ConstrOptions<COMP extends ConstrComponent, EMITS extends ConstrItem, P extends ConstrItem> = {
     components?: COMP;
     compMod?: ConstrComponentMod<P>;
@@ -1041,108 +809,66 @@ export type ConstrOptions<COMP extends ConstrComponent, EMITS extends ConstrItem
     classes?: RefType<ConstrClasses>;
     styles?: RefType<ConstrStyles>;
 };
-/**
- * Constructor setup.
- */
 export type ConstrSetup<E extends Element, CLASSES extends ConstrClasses, SETUP extends ConstrItem> = {
     name: string;
     element: Ref<E | undefined>;
     classes: RefType<CLASSES>;
     styles: RefType<ConstrStyles>;
 } & SETUP;
-/** Registration config */
-export type ConstrRegistration = {
-    flag?: boolean;
-    translate?: Record<string, string>;
-};
-/**
- * Component bind with class/style.
- */
+export type ConstrRegistration = { flag?: boolean; translate?: Record<string, string>; };
 export type ConstrBind<T> = T & Record<string, any> & {
     key?: string;
     class?: ConstrClass;
     style?: ConstrStyles;
 };
-/** Vue prop definition options */
 export type ConstrPropItemOptions<T = any> = {
     type?: PropType<T>;
     required?: boolean;
     default?: any;
     validator?(value: any, props: any): boolean;
 };
-/** Constructor prop element */
 export type ConstrPropItem<T = any> = ConstrPropItemOptions<T> | PropType<T>;
-/** Component prop definitions */
-export type ConstrProps<P = Record<string, any>> = {
-    [K in keyof P]: ConstrPropItem<P[K]>;
-};
-/** Link properties */
-export type ConstrHrefProps = {
-    href?: string;
-};
+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
-/** List item types */
+import { NumberOrString, NumberOrStringOrBoolean } from '@dxtmisha/functional-basic';
+import { ConstrBind } from './constructorTypes';
 export type ListType = 'item' | 'space' | 'line' | 'subtitle' | 'html' | 'menu' | 'menu-group' | 'group';
-/** Basic list item structure */
-export type ListDataBasic = {
-    label?: NumberOrString;
-    value?: any;
-    search?: string;
-};
-/** Extended list item */
+export type ListDataBasic = { label?: NumberOrString; value?: any; search?: string; };
 export type ListDataItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item & {
     parent?: string;
     type: ListType;
     index: string;
     disabled?: boolean;
 }>;
-/** Array of data items */
 export type ListList<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item>[];
-/** Data list record structure */
 export type ListRecord<Item extends ListDataBasic = ListDataBasic> = ListList<Item> | Record<string, any>;
-/**
- * List item with reactive state.
- */
 export type ListDataFullItem<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item> & {
     focus: boolean;
     highlight?: string;
     selected: boolean;
     disabled?: boolean;
 };
-/** State-aware list items array */
 export type ListDataFull<Item extends ListDataBasic = ListDataBasic> = ListDataFullItem<Item>[];
-/** Entry for list creation */
 export type ListListInputItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item>;
-/**
- * List input formats.
- */
 export type ListListInput<Item extends ListDataBasic = ListDataBasic> = ListListInputItem<Item>[] | string[] | Record<string, ListListInputItem<Item>> | Record<string, string>;
-/** Single selection identifier */
 export type ListSelectedItem = NumberOrStringOrBoolean;
-/** Multiple selection items */
 export type ListSelectedList = ListSelectedItem | ListSelectedItem[];
-/** Selected label */
 export type ListName = string | number | undefined;
-/** Selected names list */
 export type ListNames = ListName[];
+
 // File: src/types/refTypes.d.ts
-/** Vue reactive ref or computed */
+import { ComputedRef, Ref, VNode, VNodeArrayChildren } from 'vue';
 export type RefType<T> = ComputedRef<T> | Ref<T>;
-/** Optional reactive ref or computed */
 export type RefUndefined<T> = RefType<T | undefined>;
-/** Reactive ref or raw value */
 export type RefOrNormal<T> = RefType<T> | T;
-/** Raw Vue children content */
+export type RefOrNormalOrFunction<T> = RefOrNormal<T> | (() => RefOrNormal<T>);
 export type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
-/**
- * Raw Vue slots structure.
- */
-export type RawSlots = {
-    [name: string]: unknown;
-    $stable?: boolean;
-};
+export type RawSlots = { [name: string]: unknown; $stable?: boolean; };
+
 // File: src/types/searchTypes.d.ts
-/** Reactive search list data */
+import { RefOrNormal } from './refTypes';
+import { SearchItem, SearchListValue } from '@dxtmisha/functional-basic';
 export type SearchListValueRef<T extends SearchItem> = RefOrNormal<SearchListValue<T>>;
-/** Search list input formats */
 export type SearchListInput<T extends SearchItem> = SearchListValueRef<T> | (() => SearchListValueRef<T>);

package/dist/library.js

@@ -371,6 +371,9 @@ var Oe = class {
 	static set(e) {
 		u.set(e, !0), this.get().value = u.getItem();
 	}
+	static setValueDefault(e) {
+		u.setValueDefault(e), this.get().value = u.getItem();
+	}
 };
 J = Y, H(Y, "country", I(() => J.get().value.country)), H(Y, "language", I(() => J.get().value.language)), H(Y, "standard", I(() => J.get().value.standard)), H(Y, "firstDay", I(() => J.get().value.firstDay));
 //#endregion
@@ -1306,7 +1309,7 @@ function Dt(e, t) {
 //#endregion
 //#region src/functions/dxtFunctionalPlugin.ts
 var Ot = { install(t, n = {}) {
-	if (n.api && e.setConfig(n.api), n.translate && b.setConfig(n.translate), n.icons && m.setConfig(n.icons), n.metaSuffix && _t().setSuffix(n.metaSuffix), n.router) X.set(n.router);
+	if (n.api && e.setConfig(n.api), n.translate && b.setConfig(n.translate), n.location && Y.setValueDefault(n.location), n.icons && m.setConfig(n.icons), n.metaSuffix && _t().setSuffix(n.metaSuffix), n.router) X.set(n.router);
 	else {
 		let e = t.config.globalProperties.$router;
 		e && X.set(e);

package/dist/src/classes/ref/GeoRef.d.ts

@@ -55,4 +55,11 @@ export declare class GeoRef {
      * код страны, полный вид язык-страна или один из них
      */
     static set(code: string): void;
+    /**
+     * Sets the default value for the country code.
+     *
+     * Устанавливает значение по умолчанию для кода страны.
+     * @param code default code value / значение кода по умолчанию
+     */
+    static setValueDefault(code?: string): void;
 }

package/dist/src/functions/dxtFunctionalPlugin.d.ts

@@ -16,6 +16,11 @@ export interface FunctionalPluginOptions {
      * Конфигурация для сервиса переводов
      */
     translate?: TranslateConfig;
+    /**
+     * Default geographical location or language code /
+     * Код географического местоположения или языка по умолчанию
+     */
+    location?: string;
     /**
      * Suffix to be appended to all page titles /
      * Суффикс, который будет добавляться ко всем заголовкам страниц

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxtmisha/functional",
   "private": false,
-  "version": "1.13.1",
+  "version": "1.13.3",
   "type": "module",
   "description": "A comprehensive library of utilities, base classes, and Vue 3 composables for reactive web development. Extends @dxtmisha/functional-basic with Composition API.",
   "keywords": [