@dxtmisha/functional 1.15.13 → 1.15.15

package/ai-types.md

@@ -1,1066 +1,760 @@
-All these methods are in the @dxtmisha/functional (v1.15.13) library.
+All these methods are in the @dxtmisha/functional (v1.15.15) library.
 
-/** Base class for working with design component constructors. @keywords design abstract constructor callback */
+/** Base abstract class for component design constructors. @keywords design abstract constructor */
 export declare abstract class DesignAbstract<T extends Record<string, any>, C extends Record<string, any>> {
-    /** Constructor @keywords design constructor initialize */
+    /** Initializes the design instance with properties, change callback, and watched keys. @keywords constructor init */
     constructor(props: T, callback?: ((event: C) => void) | undefined, changed?: string[]);
-    /** Calls the callback function. @keywords design make update */
+    /** Triggers updates and executes the callback function. @param compelled Forces data to update @keywords make update */
     make(compelled?: boolean): this;
-    /** Calls the callback function. @keywords design callback */
+    /** Executes the change callback function. @param compelled Forces data update execution @keywords callback invoke */
     makeCallback(compelled?: boolean): void;
 }
 
-/** Base class for asynchronous design construction. @keywords design async abstract class */
+/** Base abstract class for working with asynchronous constructors. @keywords design, async, abstract, constructor */
 export declare abstract class DesignAsyncAbstract<T extends Record<string, any>, C extends Record<string, any>> extends DesignAbstract<T, C> {
-    /** Makes design callbacks. @keywords make design async */
+    /** Triggers the async update process. @param compelled Forces data update. @keywords make, async, update */
     make(compelled?: boolean): this;
-    /** Makes callback asynchronously. @keywords make callback async */
+    /** Executes the asynchronous callback to update data. @param compelled Forces data update. @keywords make callback, async, promise */
     makeCallback(compelled?: boolean): Promise<void>;
-    /** Initializes event asynchronously. @keywords init event async */
-    protected abstract initEvent(): Promise<void>;
 }
 
-/** Checks properties for changes. @keywords design changed check update */
+/** Tracks and checks edited or modified values in a dataset. @keywords change detection, dirty check, watch, state tracker */
 export declare class DesignChanged<T extends Record<string, any>> {
-    /** Creates a changed tracker instance. @keywords constructor create */
+    /** Initializes change tracker with base properties and optional watched keys. @keywords constructor, init */
     constructor(props: T, watch?: string[]);
-    /** Checks if property changed. @keywords is changed check */
+    /** Checks if a specific property or list of properties has been modified. @keywords is modified, changed property, check */
     is(name: string | string[]): boolean;
-    /** Checks if any watched property changed. @keywords is changed */
+    /** Checks if any tracked data has changed. @keywords is changed, dirty check, modified */
     isChanged(): boolean;
-    /** Updates cached property values. @keywords update cache */
+    /** Updates internal snapshot to current values, resetting change status. @keywords update, sync, reset snapshot */
     update(): void;
 }
 
+/** Helper class extending DesignComponents for managing and rendering subcomponents. @keywords design components subcomponents render */
 export declare class DesignComp<COMP extends ConstrComponent, P extends ConstrItem> extends DesignComponents<COMP, P> {
 }
 
-import { ComputedRef, VNode } from 'vue';
-
-/** Manages and renders connected UI components with modifier support. @keywords design components modification render */
+import { type VNode } from 'vue';
+/** Manages connected components, prop modifications, and dynamic rendering. @keywords design components, component registry, dynamic renderer */
 export declare class DesignComponents<COMP extends ConstrComponent, P extends ConstrItem> {
-    /** Creates a component manager instance. @keywords constructor design components */
+    /** Initializes component registry and modification definitions. @keywords constructor, init components */
     constructor(components?: COMP, modification?: ConstrComponentMod<P> | undefined);
-    /** Checks if a component exists by name. @keywords check component exists */
+    /** Checks whether a component exists in the registry. @keywords check component, has component, component exists */
     is<K extends keyof COMP>(name: K): name is K;
-    /** Retrieves a component by name. @keywords get component */
+    /** Retrieves a component definition by name. @keywords get component, component lookup */
     get<K extends keyof COMP>(name: K): COMP[K];
-    /** Computes and returns modified component properties. @keywords get modification props */
+    /** Returns modified input properties for connected components. @keywords component modification, props override */
     getModification<K extends keyof P>(index?: K & string | string, props?: P[K] | Record<string, any>): Record<string, any> | undefined;
-    /** Renders a component and returns an array containing the VNode. @keywords render component array */
+    /** Renders a component by name and returns an array containing the VNode. @keywords render component, vnode array */
     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 a single component VNode. @keywords render one component */
+    /** Renders a single component VNode by name. @keywords render single component, render vnode */
     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;
-    /** Renders a component and appends it to an array. @keywords render add component */
+    /** Renders a component and appends the resulting VNode to the target array. @keywords render add, append vnode */
     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;
-    /** Computes modifications for a specific component index. @keywords compute modification */
-    protected computeModification<K extends keyof P>(index: K & string | string): Record<string, any>;
 }
 
-import { ComputedRef, ToRefs, VNode, Ref } from 'vue';
-/** Component constructor abstract class. @keywords design constructor abstract component */
+import { type ComputedRef, type ToRefs, type VNode } from 'vue';
+/** Abstract base constructor for collecting and managing functional design components. @keywords design constructor, abstract component */
 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> {
-    /** Creates instance of design constructor. @keywords constructor design */
-    protected constructor(name: string, props: Readonly<P>, options?: ConstrOptions<COMP, EMITS, P> | undefined);
-    /** Initializes instance properties. @keywords init design */
-    protected init(): this;
-    /** Gets full class name. @keywords get name class */
+    /** Gets the component class name. @keywords component name, class name */
     getName(): string;
-    /** Gets design prefix/name. @keywords get design */
+    /** Gets the design name. @keywords design name */
     getDesign(): string;
-    /** Gets sub-class name by levels. @keywords get sub class */
+    /** Gets the sub-element class name by hierarchical level. @keywords sub class, class name */
     getSubClass(name: string | string[]): string;
-    /** Gets status modifier class name. @keywords get status class */
+    /** Gets the status modifier class name. @keywords status class, state */
     getStatusClass(name: string | string[]): string;
-    /** Gets CSS custom property name. @keywords get style var */
+    /** Gets the style property name. @keywords style property */
     getStyle(name: string | string[]): string;
-    /** Gets filtered element attributes. @keywords get attrs */
+    /** Gets additional component attributes. @keywords attributes, attrs */
     getAttrs(): ConstrItem;
-    /** Exposes public component properties and element. @keywords expose component */
+    /** Gets key and class attributes for a sub-element. @keywords key class, sub element */
+    getKeyClass<K extends keyof CLASSES>(name: K & string): {
+        key: K & string;
+        class: any;
+    };
+    /** Exposes public properties and methods to the component instance. @keywords expose, public api */
     expose(): ConstrExpose<E, EXPOSE>;
-    /** Returns component render function. @keywords render function */
+    /** Render function generator for the setup execution context. @keywords render, setup */
     render(): () => VNode | (VNode | any)[] | undefined;
-    /** Initializes exposed context. @keywords init expose */
-    protected abstract initExpose(): EXPOSE;
-    /** Initializes computed CSS classes. @keywords init classes */
-    protected abstract initClasses(): Partial<CLASSES>;
-    /** Initializes computed inline styles. @keywords init styles */
-    protected abstract initStyles(): ConstrStyles;
-    /** Renders component template VNode. @keywords init render */
-    protected abstract initRender(): VNode | (VNode | any)[] | undefined;
-    /** Initializes slot content and optionally pushes to children. @keywords init slot */
-    protected initSlot<K extends keyof SLOTS>(name: K, children?: any[], props?: ConstrItem): VNode | undefined;
-    /** Normalizes class definition into class object map. @keywords to class */
-    protected toClass(classes?: ConstrClass): ConstrClassObject;
-    /** Maps class definition placeholders to component names. @keywords to class name */
-    protected toClassName<T extends ConstrItem>(classes?: ConstrItem): T;
 }
 
-import { ComputedRef, Ref } from 'vue';
-import { Datetime, GeoDate, GeoFirstDay, GeoHours, NumberOrStringOrDate } from '@dxtmisha/functional-basic';
+import { type ComputedRef, type Ref } from 'vue';
+import { Datetime, type GeoDate, type GeoFirstDay, type GeoHours, type NumberOrStringOrDate } from '@dxtmisha/functional-basic';
 
-/** @keywords DatetimeRef, date, reactive, time */
+/** Reactive wrapper for date operations and localization. @keywords datetime date time reactive vue */
 export declare class DatetimeRef {
-    /** @keywords constructor, init */
+    /** Initializes a new DatetimeRef instance. @keywords constructor datetime init */
     constructor(date: RefOrNormal<NumberOrStringOrDate>, type?: RefOrNormal<GeoDate>, code?: RefOrNormal<string>);
-    /** @keywords getItem, date, ref */
+    /** Returns the raw reactive date value. @keywords item value raw */
     getItem(): Ref<NumberOrStringOrDate>;
-    /** @keywords getDate, date */
+    /** Returns the reactive Date object. @keywords date object */
     getDate(): Ref<Date>;
-    /** @keywords getDatetime, datetime */
+    /** Returns the underlying basic Datetime instance. @keywords datetime instance base */
     getDatetime(): Datetime;
-    /** @keywords getHoursType, hours */
+    /** Returns the reactive hour format type. @keywords hours format type 12h 24h */
     getHoursType(): ComputedRef<GeoHours>;
-    /** @keywords getFirstDayCode, firstDay */
+    /** Returns the reactive first day of the week code. @keywords first day week code */
     getFirstDayCode(): ComputedRef<GeoFirstDay>;
-    /** @keywords getYear, year */
+    /** Returns the reactive year according to local time. @keywords year local */
     getYear(): ComputedRef<number>;
-    /** @keywords getMonth, month */
+    /** Returns the reactive zero-based month index according to local time. @keywords month index local */
     getMonth(): ComputedRef<number>;
-    /** @keywords getDay, day */
+    /** Returns the reactive day of the month according to local time. @keywords day month local */
     getDay(): ComputedRef<number>;
-    /** @keywords getHour, hour */
+    /** Returns the reactive hour according to local time. @keywords hour local */
     getHour(): ComputedRef<number>;
-    /** @keywords getMinute, minute */
+    /** Returns the reactive minutes according to local time. @keywords minute local */
     getMinute(): ComputedRef<number>;
-    /** @keywords getSecond, second */
+    /** Returns the reactive seconds according to local time. @keywords second local */
     getSecond(): ComputedRef<number>;
-    /** @keywords getMaxDay, maxDay */
+    /** Returns the reactive maximum number of days in the month. @keywords max day month days */
     getMaxDay(): ComputedRef<number>;
-    /** @keywords locale, format */
+    /** Returns localized date/time string based on format and style options. @keywords locale format intl */
     locale(type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions): ComputedRef<string>;
-    /** @keywords standard, format */
+    /** Returns standard formatted date string with optional time zone. @keywords standard format timezone */
     standard(timeZone?: boolean): ComputedRef<string>;
-    protected updateDate(): this;
 }
 
-/** Global effect scope class. @keywords effect scope global scope */
+/** Global effect scope container. @keywords effect scope, reactivity, global scope */
 export declare class EffectScopeGlobal {
-    /** Runs a function within the global scope. @keywords run execute global scope */
+    /** Runs a callback within the global effect scope. @keywords run, execute, global effect scope */
     static run<T>(fn: () => T): T | undefined;
-    /** Gets the global effect scope instance. @keywords get scope instance global */
-    static getScope(): import("vue").EffectScope;
 }
 
-import { ElementOrString, ElementOrWindow, EventItem, EventListenerDetail, EventOptions } from '@dxtmisha/functional-basic';
+import { type ElementOrString, type ElementOrWindow, EventItem, type EventListenerDetail, type EventOptions } from '@dxtmisha/functional-basic';
 
-/**
- * Class for working with events using reactive references.
- * @keywords event_ref event_wrapper reactive_event dom_event
- */
+/** Class for managing DOM event listeners with reactive reference targets. @keywords event, listener, ref, dom, reactive */
 export declare class EventRef<E extends ElementOrWindow, O extends Event, D extends Record<string, any> = Record<string, any>> extends EventItem<E, O, D> {
-    /**
-     * Creates an instance of EventRef.
-     * @keywords constructor event_ref_init
-     */
+    /** Creates an instance of EventRef. @keywords constructor, event, ref */
     constructor(elementSelector?: RefOrNormal<ElementOrString<E> | undefined>, elementSelectorControl?: RefOrNormal<ElementOrString<HTMLElement>>, type?: string | string[], listener?: EventListenerDetail<O, D>, options?: EventOptions, detail?: D);
 }
 
-import { ComputedRef } from 'vue';
-import { GeoFlagItem, GeoFlagNational } from '@dxtmisha/functional-basic';
+import { type ComputedRef } from 'vue';
+import { type GeoFlagItem, type GeoFlagNational } from '@dxtmisha/functional-basic';
 
-/** Geo flag reactive reference manager. @keywords geo, flag, country, language */
+/** Reactive wrapper for managing geo flags and country/language information. @keywords geo, flag, country, language, reactive */
 export declare class GeoFlagRef {
-    /**
-     * Creates a new GeoFlagRef instance.
-     * @param code Country or language code
-     */
+    /** Initializes the reactive geo flag manager with an optional country or language code. @keywords constructor, init */
     constructor(code?: RefOrNormal<string | undefined>);
-    /** Gets the current country code. @keywords code, get */
+    /** Retrieves the resolved country code. @keywords country_code, get_code */
     getCode(): string;
-    /** Gets reactive country flag item information. @keywords country, flag, item */
+    /** Retrieves reactive country and flag metadata. @keywords country, flag_item, metadata */
     get(code?: RefOrNormal<string>): ComputedRef<GeoFlagItem | undefined>;
-    /** Gets reactive language flag item information. @keywords language, flag, item */
+    /** Retrieves reactive language and flag metadata. @keywords language, flag_item, metadata */
     getLanguage(code?: RefOrNormal<string>): ComputedRef<GeoFlagItem | undefined>;
-    /** Gets reactive flag image URL or source. @keywords flag, link, image */
+    /** Retrieves a reactive link or URL to the flag asset. @keywords flag_url, flag_link */
     getFlag(code?: RefOrNormal<string>): ComputedRef<string | undefined>;
-    /** Gets a reactive list of country flag items. @keywords list, country, flags */
+    /** Retrieves a reactive list of country flag items filtered by codes. @keywords country_list, flag_list */
     getList(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagItem[]>;
-    /** Gets a reactive list of language flag items. @keywords list, language, flags */
+    /** Retrieves a reactive list of language flag items filtered by codes. @keywords language_list, flag_list */
     getListLanguage(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagItem[]>;
-    /** Gets reactive country flag items in national representation. @keywords national, country, list */
+    /** Retrieves a reactive list of country flag items in their national language. @keywords national_names, country_national */
     getNational(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
-    /** Gets reactive language flag items in national representation. @keywords national, language, list */
+    /** Retrieves a reactive list of language flag items in their national language. @keywords national_languages, language_national */
     getNationalLanguage(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
 }
 
-import { ComputedRef } from 'vue';
-import { GeoDate, ItemValue, NumberOrString, NumberOrStringOrDate } from '@dxtmisha/functional-basic';
-
+import { type ComputedRef } from 'vue';
+import { type GeoDate, type ItemValue, type NumberOrString, type NumberOrStringOrDate } from '@dxtmisha/functional-basic';
 /**
- * Reactive class for managing the formatting of numbers and dates.
- * @keywords geo intl format reactive number date localize
+ * Reactive internationalization formatter for numbers, dates, currencies, and units.
+ * @remarks Use standard `GeoIntl` if reactivity is not required.
+ * @keywords i18n, intl, reactive, localization, format
  */
 export declare class GeoIntlRef {
-    /**
-     * Constructor for GeoIntlRef.
-     * @keywords constructor initialize geo intl ref
-     */
+    /** Initializes reactive GeoIntl instance with locale code. @keywords constructor, locale */
     constructor(code?: RefOrNormal<string>);
-
-    /**
-     * Format display names for language, region, and script.
-     * @keywords display name language region script intl
-     */
+    /** Translates language, region, and script display names reactively. @keywords displayNames, translation, locale */
     display(value?: RefOrNormal<string>, typeOptions?: Intl.DisplayNamesOptions['type'] | Intl.DisplayNamesOptions): ComputedRef<string>;
-
-    /**
-     * Get display names of language.
-     * @keywords language name translate intl
-     */
+    /** Returns reactive display name of a language. @keywords language, displayNames, locale */
     languageName(value?: RefOrNormal<string>, style?: Intl.RelativeTimeFormatStyle): ComputedRef<string>;
-
-    /**
-     * Get display names of region.
-     * @keywords country region name intl
-     */
+    /** Returns reactive display name of a region or country. @keywords country, region, displayNames, locale */
     countryName(value?: RefOrNormal<string>, style?: Intl.RelativeTimeFormatStyle): ComputedRef<string>;
-
-    /**
-     * Format a number value.
-     * @keywords number format intl digit
-     */
+    /** Formats number reactively using locale rules. @keywords numberFormat, format, locale */
     number(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Get the decimal point symbol.
-     * @keywords decimal point symbol separator
-     */
+    /** Returns decimal point symbol for current locale. @keywords decimal, separator, symbol */
     decimal(): ComputedRef<string>;
-
-    /**
-     * Format a currency value.
-     * @keywords currency format money price intl
-     */
+    /** Formats currency amount reactively. @keywords currency, money, format */
     currency(value: RefOrNormal<NumberOrString>, currencyOptions?: RefOrNormal<string | Intl.NumberFormatOptions>, numberOnly?: boolean): ComputedRef<string>;
-
-    /**
-     * Get the currency symbol or code.
-     * @keywords currency symbol code intl
-     */
+    /** Returns currency symbol or code for specified currency. @keywords currencySymbol, currencyCode */
     currencySymbol(currency: RefOrNormal<string>, currencyDisplay?: keyof Intl.NumberFormatOptionsCurrencyDisplayRegistry): ComputedRef<string>;
-
-    /**
-     * Format a unit value.
-     * @keywords unit format measurement intl
-     */
+    /** Formats value with measurement unit reactively. @keywords unit, measurement, format */
     unit(value: RefOrNormal<NumberOrString>, unitOptions?: string | Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Format a file size value.
-     * @keywords size file bytes megabytes intl
-     */
+    /** Formats file size in bytes reactively. @keywords fileSize, bytes, format */
     sizeFile(value: RefOrNormal<NumberOrString>, unitOptions?: 'byte' | 'kilobyte' | 'megabyte' | 'gigabyte' | 'terabyte' | 'petabyte' | Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Format a number as a percentage.
-     * @keywords percent percentage format intl
-     */
+    /** Formats number as percentage reactively. @keywords percent, percentage, format */
     percent(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Format a number as a percentage by 100.
-     * @keywords percent 100 format intl
-     */
+    /** Formats number multiplied by 100 as percentage reactively. @keywords percent, percentage, format */
     percentBy100(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Format text based on plural rules and language words.
-     * @keywords plural rules words format intl
-     */
+    /** Formats string applying locale-sensitive pluralization rules. @param words Format: "one|two|few|many|other|zero" @keywords plural, pluralRules */
     plural(value: RefOrNormal<NumberOrString>, words: string, options?: Intl.PluralRulesOptions, optionsNumber?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Format a date and time value.
-     * @keywords date time format intl calendar
-     */
+    /** Formats date and time reactively. @keywords date, dateTime, format */
     date(value: RefOrNormal<NumberOrStringOrDate>, type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions, hour24?: boolean): ComputedRef<string>;
-
-    /**
-     * Format relative time.
-     * @keywords relative time ago format intl
-     */
+    /** Formats relative time reactively. @keywords relativeTime, timeAgo, format */
     relative(value: RefOrNormal<NumberOrStringOrDate>, styleOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions, todayValue?: Date): ComputedRef<string>;
-
-    /**
-     * Format relative time with a limit falling back to standard date.
-     * @keywords relative time limit format intl
-     */
+    /** Formats relative time with fallback limit to standard date format. @keywords relativeLimit, relativeTime, fallback */
     relativeLimit(value: RefOrNormal<NumberOrStringOrDate>, limit: number, todayValue?: Date, relativeOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions, dateOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions, type?: GeoDate, hour24?: boolean): ComputedRef<string>;
-
-    /**
-     * Format relative time by specific unit and value.
-     * @keywords relative value unit time format intl
-     */
+    /** Formats relative time from a numerical value and unit. @keywords relativeByValue, relativeTime, unit */
     relativeByValue(value: RefOrNormal<NumberOrString>, unit: Intl.RelativeTimeFormatUnit, styleOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions): ComputedRef<string>;
-
-    /**
-     * Get the name of a month.
-     * @keywords month name date format intl
-     */
+    /** Returns month name reactively. @keywords month, monthName */
     month(value?: RefOrNormal<NumberOrStringOrDate>, style?: Intl.DateTimeFormatOptions['month']): ComputedRef<string>;
-
-    /**
-     * Get an array of all months.
-     * @keywords months list array intl
-     */
+    /** Returns list of all localized month names. @keywords months, monthList */
     months(style?: Intl.DateTimeFormatOptions['month']): ComputedRef<ItemValue<number | undefined>[]>;
-
-    /**
-     * Get the name of a weekday.
-     * @keywords weekday name date format intl
-     */
+    /** Returns weekday name reactively. @keywords weekday, dayName */
     weekday(value?: RefOrNormal<NumberOrStringOrDate>, style?: Intl.DateTimeFormatOptions['weekday']): ComputedRef<string>;
-
-    /**
-     * Get an array of all weekdays.
-     * @keywords weekdays list array intl
-     */
+    /** Returns list of all localized weekday names. @keywords weekdays, weekdayList */
     weekdays(style?: Intl.DateTimeFormatOptions['weekday']): ComputedRef<ItemValue<number | undefined>[]>;
-
-    /**
-     * Format time.
-     * @keywords time format intl
-     */
+    /** Formats time reactively. @keywords time, timeFormat */
     time(value: RefOrNormal<NumberOrStringOrDate>): ComputedRef<string>;
-
-    /**
-     * Sort an array of items taking into account locale specifics.
-     * @keywords sort locale array intl
-     */
+    /** Sorts array elements taking into account locale collation rules. @keywords sort, collation, localeCompare */
     sort<T>(data: RefOrNormal<T[]>, compareFn?: (a: T, b: T) => [string, string]): ComputedRef<T[]>;
 }
 
-import { ComputedRef, Ref } from 'vue';
-import { GeoItemFull } from '@dxtmisha/functional-basic';
-
-/** Geo reference reactive manager class @keywords geo ref country language */
+import { type ComputedRef, type Ref } from 'vue';
+import { type GeoItemFull } from '@dxtmisha/functional-basic';
+/** Reactive class for geographic and locale data management. @keywords geo, location, country, language, locale */
 export declare class GeoRef {
-	/** Get reactive geographic full item @keywords get geo item */
-	static get(): Ref<GeoItemFull>;
-	/** Get current country code @keywords country code */
-	static getCountry(): ComputedRef<string>;
-	/** Get current language code @keywords language code */
-	static getLanguage(): ComputedRef<string>;
-	/** Get standard format string @keywords standard locale */
-	static getStandard(): ComputedRef<string>;
-	/** Get first day of the week @keywords first day */
-	static getFirstDay(): ComputedRef<string>;
-	/** Get current location string @keywords location */
-	static getLocation(): ComputedRef<string>;
-	/** Get country from location @keywords location country */
-	static getLocationCountry(): ComputedRef<string>;
-	/** Get language from location @keywords location language */
-	static getLocationLanguage(): ComputedRef<string>;
-	/** Set geographic code @keywords set geo */
-	static set(code: string): void;
-	/** Set default geographic value @keywords default geo */
-	static setValueDefault(code?: string | (() => string)): void;
+    /** Returns reactive object with full geographic information. @keywords geo, country, info, ref */
+    static get(): Ref<GeoItemFull>;
+    /** Returns reactive string with current country code. @keywords country, code, geo */
+    static getCountry(): ComputedRef<string>;
+    /** Returns reactive string with current language code. @keywords language, code, locale */
+    static getLanguage(): ComputedRef<string>;
+    /** Returns reactive string with full standard locale format. @keywords standard, locale, format */
+    static getStandard(): ComputedRef<string>;
+    /** Returns reactive string representing first day of the week. @keywords first day, week, calendar */
+    static getFirstDay(): ComputedRef<string>;
+    /** Returns reactive string with current location identifier. @keywords location, geo */
+    static getLocation(): ComputedRef<string>;
+    /** Returns reactive string with current country code from location. @keywords location, country */
+    static getLocationCountry(): ComputedRef<string>;
+    /** Returns reactive string with current language code from location. @keywords location, language */
+    static getLocationLanguage(): ComputedRef<string>;
+    /** Updates geographic data by locale or country code. @keywords set, update, locale, geo */
+    static set(code: string): void;
+    /** Sets default country code value or resolver function. @keywords default, fallback, country */
+    static setValueDefault(code?: string | (() => string)): void;
 }
 
-import { ComputedRef, Ref } from 'vue';
-import { GeoUnit, NumberOrString } from '@dxtmisha/functional-basic';
-
-/**
- * Reactive class for managing localized unit formatting and automatic conversions.
- * @keywords GeoUnitRef, geo, unit, formatting, conversion, localized
- */
+import { type ComputedRef, type Ref } from 'vue';
+import { GeoUnit, type NumberOrString } from '@dxtmisha/functional-basic';
+/** Reactive manager for localized unit formatting and automatic conversions. @keywords geo, unit, format, localization, vue, reactive */
 export declare class GeoUnitRef {
-    /**
-     * Creates an instance of GeoUnitRef.
-     * @keywords constructor, geo, unit
-     */
+    /** Initializes GeoUnitRef with an optional country or locale code. @keywords constructor, locale */
     constructor(code?: RefOrNormal<string>);
-
-    /**
-     * Returns the standard location code.
-     * @keywords getLocation, location, code, standard
-     */
+    /** Returns the standard location code as a computed reference. @keywords location, locale, computed */
     getLocation(): ComputedRef<string>;
-
-    /**
-     * Formats millimeter value, converting to inches if overridden by locale unit settings.
-     * @keywords millimeter, format, length, unit
-     */
+    /** Formats millimeter value, converting to inches if required by locale. @keywords millimeter, mm, length, format */
     millimeter(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats centimeter value, converting to inches if overridden by locale unit settings.
-     * @keywords centimeter, format, length, unit
-     */
+    /** Formats centimeter value, converting to inches if required by locale. @keywords centimeter, cm, length, format */
     centimeter(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats meter value, converting to feet if overridden by locale unit settings.
-     * @keywords meter, format, length, unit
-     */
+    /** Formats meter value, converting to feet if required by locale. @keywords meter, length, format */
     meter(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats kilometer value, converting to miles if overridden by locale unit settings.
-     * @keywords kilometer, format, length, unit
-     */
+    /** Formats kilometer value, converting to miles if required by locale. @keywords kilometer, km, distance, format */
     kilometer(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats square meter value, converting to square feet if overridden by locale unit settings.
-     * @keywords squareMeter, format, area, unit
-     */
+    /** Formats square meter value, converting to square feet if required by locale. @keywords square meter, area, format */
     squareMeter(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats hectare value, converting to acres if overridden by locale unit settings.
-     * @keywords hectare, format, area, unit
-     */
+    /** Formats hectare value, converting to acres if required by locale. @keywords hectare, area, format */
     hectare(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats gram value, converting to ounces if overridden by locale unit settings.
-     * @keywords gram, format, mass, weight, unit
-     */
+    /** Formats gram value, converting to ounces if required by locale. @keywords gram, weight, mass, format */
     gram(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats kilogram value, converting to pounds if overridden by locale unit settings.
-     * @keywords kilogram, format, mass, weight, unit
-     */
+    /** Formats kilogram value, converting to pounds if required by locale. @keywords kilogram, kg, weight, format */
     kilogram(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats tonne value, converting to short tons if overridden by locale unit settings.
-     * @keywords tonne, format, mass, weight, unit
-     */
+    /** Formats tonne value, converting to short tons if required by locale. @keywords tonne, weight, mass, format */
     tonne(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats milliliter value, converting to fluid ounces if overridden by locale unit settings.
-     * @keywords milliliter, format, volume, unit
-     */
+    /** Formats milliliter value, converting to fluid ounces if required by locale. @keywords milliliter, ml, volume, format */
     milliliter(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats liter value, converting to gallons if overridden by locale unit settings.
-     * @keywords liter, format, volume, unit
-     */
+    /** Formats liter value, converting to gallons if required by locale. @keywords liter, volume, format */
     liter(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats celsius value, converting to fahrenheit if overridden by locale unit settings.
-     * @keywords celsius, format, temperature, unit
-     */
+    /** Formats celsius value, converting to fahrenheit if required by locale. @keywords celsius, temperature, format */
     celsius(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats kilometer per hour value, converting to miles per hour if overridden by locale unit settings.
-     * @keywords kilometerPerHour, format, speed, unit
-     */
+    /** Formats kilometer per hour value, converting to mph if required by locale. @keywords speed, kilometerPerHour, velocity, format */
     kilometerPerHour(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
-
-    /**
-     * Formats the value for the specified unit reactively, converting and formatting it according to the locale.
-     * @keywords format, unit, conversion, localized
-     */
+    /** Reactively formats a value for a specified unit according to locale settings. @keywords format, unit, locale */
     format(value: RefOrNormal<NumberOrString>, unit: RefOrNormal<string>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
 }
 
-import { ComputedRef } from 'vue';
-
-/**
- * Class for managing the data list.
- * @keywords list data management collection items
- */
+/** Reactive data list management with search, focus, selection, and navigation. @keywords list, data, reactive, selection, focus */
 export declare class ListDataRef {
-    /**
-     * Creates an instance of ListData for managing list data.
-     * @keywords list data constructor initialize
-     */
+    /** Initializes list data manager with reactive configurations. @keywords constructor, init */
     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);
-    /**
-     * Returns a list for forming a list.
-     * @keywords list items data reactive
-     */
-    readonly data: ComputedRef<ListList>;
-    /**
-     * Returns a simplified list for quick loading.
-     * @keywords lite list fast items
-     */
-    readonly liteData: ComputedRef<ListList>;
-    /**
-     * Returns a list of records with all additional data.
-     * @keywords full list data items state
-     */
-    readonly fullData: ComputedRef<ListDataFull>;
-    /**
-     * Returns a flat map of all entries including sublists.
-     * @keywords map flat list items
-     */
-    readonly map: ComputedRef<ListList>;
-    /**
-     * Returns a list consisting only of items.
-     * @keywords map items array
-     */
-    readonly mapItems: ComputedRef<ListList>;
-    /**
-     * Returns a list consisting only of values for selection.
-     * @keywords items selection values group menu
-     */
-    readonly items: ComputedRef<ListList>;
-    /**
-     * Finds the first element that meets the search conditions.
-     * @keywords highlight first item search index
-     */
-    readonly highlightFirstItem: ComputedRef<number>;
-    /**
-     * Is there a selected item.
-     * @keywords is selected boolean state
-     */
-    readonly isSelected: ComputedRef<boolean>;
-    /**
-     * Is the minimum selection reached.
-     * @keywords is selected min threshold
-     */
-    readonly isSelectedMin: ComputedRef<boolean>;
-    /**
-     * Is the maximum selection reached.
-     * @keywords is selected max threshold
-     */
-    readonly isSelectedMax: ComputedRef<boolean>;
-    /**
-     * Returns a list of selected items on the map.
-     * @keywords selected list items
-     */
-    readonly selectedList: ComputedRef<ListList>;
-    /**
-     * Returns a list of selected items in the current group.
-     * @keywords selected list group items
-     */
-    readonly selectedListInGroup: ComputedRef<ListList>;
-    /**
-     * Returns a list of selected labels on the map.
-     * @keywords selected names labels list
-     */
-    readonly selectedNames: ComputedRef<ListNames>;
-    /**
-     * Returns a list of selected values on the map.
-     * @keywords selected values list
-     */
-    readonly selectedValues: ComputedRef<any[]>;
-    /**
-     * Checks whether it is necessary to first display a simplified version.
-     * @keywords is lite mode check
-     */
+    /** Reactive list formatted for display. @keywords data, items, list */
+    readonly data: import("vue").ComputedRef<ListList>;
+    /** Simplified reactive list for fast rendering. @keywords lite, fast-load */
+    readonly liteData: import("vue").ComputedRef<ListList>;
+    /** Detailed reactive records including selection and focus state. @keywords full-data, records */
+    readonly fullData: import("vue").ComputedRef<ListDataFull>;
+    /** Flat map containing all records including sublists. @keywords map, flat */
+    readonly map: import("vue").ComputedRef<ListList>;
+    /** Flat list containing item-type entries only. @keywords map-items, entries */
+    readonly mapItems: import("vue").ComputedRef<ListList>;
+    /** Reactive selectable list items. @keywords items, selectable */
+    readonly items: import("vue").ComputedRef<ListList>;
+    /** Index of first item matching search highlight criteria. @keywords highlight, search-index */
+    readonly highlightFirstItem: import("vue").ComputedRef<number>;
+    /** Indicates whether any item is currently selected. @keywords selected, check */
+    readonly isSelected: import("vue").ComputedRef<boolean>;
+    /** Indicates whether minimum selection threshold is satisfied. @keywords min-selection, limit */
+    readonly isSelectedMin: import("vue").ComputedRef<boolean>;
+    /** Indicates whether maximum selection threshold is reached. @keywords max-selection, limit */
+    readonly isSelectedMax: import("vue").ComputedRef<boolean>;
+    /** List of currently selected items across full map. @keywords selected-list */
+    readonly selectedList: import("vue").ComputedRef<ListList>;
+    /** List of currently selected items within active group. @keywords selected-group */
+    readonly selectedListInGroup: import("vue").ComputedRef<ListList>;
+    /** List of display labels for selected items. @keywords labels, selected-names */
+    readonly selectedNames: import("vue").ComputedRef<ListNames>;
+    /** Array of raw values for selected items. @keywords values, selected-values */
+    readonly selectedValues: import("vue").ComputedRef<any[]>;
+    /** Checks if lite rendering mode is enabled. @keywords lite-check */
     isLite(): boolean;
-    /**
-     * Checks if an element is in focus.
-     * @keywords is focus check
-     */
+    /** Checks if any item is focused. @keywords focus-check */
     isFocus(): boolean;
-    /**
-     * Checks if there is a highlighted item (search results).
-     * @keywords is highlight check search
-     */
+    /** Checks if search highlight matches exist. @keywords highlight-check */
     isHighlight(): boolean;
-    /**
-     * Checks if highlighting is active (minimum length reached).
-     * @keywords is highlight active check
-     */
+    /** Checks if search query meets minimum highlight length. @keywords highlight-active */
     isHighlightActive(): boolean;
-    /**
-     * Returns the number of records in the current list.
-     * @keywords get length count list
-     */
+    /** Total count of records in current view. @keywords length, count */
     getLength(): number;
-    /**
-     * Returns the number of all available records in the map.
-     * @keywords get length map count
-     */
+    /** Total count of all mapped records. @keywords map-length, count */
     getLengthByMap(): number;
-    /**
-     * Returns the number of all available records (items).
-     * @keywords get length items count
-     */
+    /** Total count of selectable items. @keywords items-length, count */
     getLengthByItems(): number;
-    /**
-     * Returns the identifier in focus.
-     * @keywords get focus identifier
-     */
+    /** Returns identifier of currently focused item. @keywords get-focus */
     getFocus(): ListSelectedItem | undefined;
-    /**
-     * Returns the item in focus.
-     * @keywords get focus item data
-     */
+    /** Returns record of currently focused item. @keywords get-focus-item */
     getFocusItem(): ListDataItem | undefined;
-    /**
-     * Returns the highlight text.
-     * @keywords get highlight search text
-     */
+    /** Returns active highlight search string. @keywords get-highlight */
     getHighlight(): string | undefined;
-    /**
-     * Returns the minimum length for highlight to start.
-     * @keywords get highlight length start
-     */
+    /** Returns minimum query length required to trigger highlight. @keywords highlight-length */
     getHighlightLengthStart(): number;
-    /**
-     * Returns the selected identifiers list.
-     * @keywords get selected list
-     */
+    /** Returns list of selected item identifiers. @keywords get-selected */
     getSelected(): ListSelectedList | undefined;
-    /**
-     * Returns an item by moving a certain number of steps from the selected item.
-     * @keywords get selected by step navigation
-     */
+    /** Finds selected identifier offset by given step. @keywords selected-step */
     getSelectedByStep(step: number): ListSelectedItem | undefined;
-    /**
-     * Returns the next item from the selected one.
-     * @keywords get selected next item
-     */
+    /** Finds next selected identifier. @keywords selected-next */
     getSelectedNext(): ListSelectedItem | undefined;
-    /**
-     * Returns the previous item from the selected one.
-     * @keywords get selected prev item
-     */
+    /** Finds previous selected identifier. @keywords selected-prev */
     getSelectedPrev(): ListSelectedItem | undefined;
-    /**
-     * Returns an item by moving a certain number of steps from the specified item.
-     * @keywords get item by step navigation
-     */
+    /** Finds item offset by step count relative to given item. @keywords item-step */
     getItemByStep(item: ListDataItem, step: number): ListDataItem | undefined;
-    /**
-     * Returns the next item from the specified one.
-     * @keywords get item next
-     */
+    /** Finds next sequential item from given item. @keywords item-next */
     getItemNext(item: ListDataItem): ListDataItem | undefined;
-    /**
-     * Returns the previous item from the specified one.
-     * @keywords get item prev
-     */
+    /** Finds previous sequential item from given item. @keywords item-prev */
     getItemPrev(item: ListDataItem): ListDataItem | undefined;
-    /**
-     * Returns an item by moving a certain number of steps from the specified index.
-     * @keywords get index by step navigation
-     */
+    /** Finds item offset by step count relative to given index. @keywords index-step */
     getIndexByStep(index: string, step: number): ListDataItem | undefined;
-    /**
-     * Returns the next item from the specified index.
-     * @keywords get index next
-     */
+    /** Finds next sequential item after given index. @keywords index-next */
     getIndexNext(index: string): ListDataItem | undefined;
-    /**
-     * Returns the previous item from the specified index.
-     * @keywords get index prev
-     */
+    /** Finds previous sequential item before given index. @keywords index-prev */
     getIndexPrev(index: string): ListDataItem | undefined;
-    /**
-     * Returns an item by its index.
-     * @keywords get item by index
-     */
+    /** Retrieves item record and key by index identifier. @keywords item-by-index */
     getItemByIndex(index?: string): {
         key: number;
         item: ListDataItem;
     } | undefined;
-    /**
-     * Returns an item by its key.
-     * @keywords get item by key number
-     */
+    /** Retrieves item record by numeric key. @keywords item-by-key */
     getItemByKey(key: number): ListDataItem | undefined;
-    /**
-     * Returns the first item with the specified parent.
-     * @keywords get first item by parent
-     */
+    /** Retrieves first child item under specified parent. @keywords first-child, parent */
     getFirstItemByParent(parent: string | undefined): ListDataItem | undefined;
-    /**
-     * Returns the last item with the specified parent.
-     * @keywords get last item by parent
-     */
+    /** Retrieves last child item under specified parent. @keywords last-child, parent */
     getLastItemByParent(parent: string | undefined): ListDataItem | undefined;
-    /**
-     * Returns a sublist object for a group item.
-     * @keywords get sub list group item
-     */
+    /** Creates sublist manager for group item. @keywords sublist, group */
     getSubList(item: ListDataItem): ListDataRef;
 }
 
-import { RouteLocationRaw, Router, _RouterClassic } from 'vue-router';
-
-/**
- * Router management class.
- * @keywords router, navigation, ref, link, href
- */
+import type { RouteLocationRaw, Router } from 'vue-router';
+/** Router management and navigation utility. @keywords router, navigation, vue-router */
 export declare class RouterItemRef {
-	/** Get router instance. @keywords router, get */
-	static get(): _RouterClassic;
-	/** Returns the link by name. @keywords router, link, resolve */
-	static getLink(name: string, params?: any, query?: any): string | undefined;
-	/** Returns the link property by name. @keywords router, href */
-	static getHref(name?: string, params?: any, query?: any): ConstrHrefProps;
-	/** Site path change. @keywords router, push, navigate */
-	static push(to: string | RouteLocationRaw): void;
-	/** Set router instance. @keywords router, set */
-	static set(router: Router): void;
-	/** Set router instance only once. @keywords router, set, once */
-	static setOneTime(router: Router): void;
-	/** Converts the raw route location to href properties. @keywords router, href, raw */
-	static rawToHref(to?: string | RouteLocationRaw): ConstrHrefProps;
+    /** Retrieves the active router instance. @keywords router instance, get router */
+    static get(): import("vue-router")._RouterClassic;
+    /** Resolves and returns a URL link path by route name. @keywords get link, route url, resolve route */
+    static getLink(name: string, params?: any, query?: any): string | undefined;
+    /** Resolves href properties for a route by name. @keywords get href, link props, route href */
+    static getHref(name?: string, params?: any, query?: any): ConstrHrefProps;
+    /** Navigates to a target route location. @keywords navigate, router push, route change */
+    static push(to: string | RouteLocationRaw): void;
+    /** Sets the global router instance. @keywords set router, register router */
+    static set(router: Router): void;
+    /** Sets the router instance only if it has not been set previously. @keywords set router once, init router */
+    static setOneTime(router: Router): void;
+    /** Converts a raw route location into href properties. @keywords raw to href, route location, href builder */
+    static rawToHref(to?: string | RouteLocationRaw): ConstrHrefProps;
 }
 
-import { Ref, ComputedRef } from 'vue';
+import type { ComputedRef, Ref } from 'vue';
 
-/** Scrollbar width reactive reference utility class @keywords scrollbar, width, reactive, dom */
+/** Reactive scrollbar width tracker @keywords scrollbar, width, reactive, vue */
 export declare class ScrollbarWidthRef {
-    /** Reactive item state @keywords item, state, boolean */
-    readonly item: Ref<boolean | undefined, boolean | undefined>;
-    /** Reactive scrollbar width value @keywords width, number, size */
-    readonly width: Ref<number, number>;
-    /** Creates a scrollbar width reference instance @keywords constructor, init */
+    /** Reactive state indicating measurement activity @keywords reactive, state */
+    readonly item: Ref<boolean | undefined>;
+    /** Reactive scrollbar width in pixels @keywords reactive, width, scrollbar */
+    readonly width: Ref<number>;
+    /** Initializes the reactive scrollbar width tracker @keywords constructor, init */
     constructor();
-    /** Computes whether scrollbar width is available @keywords is, computed, check */
+    /** Computed flag indicating if scrollbar width is measured and defined @keywords computed, check */
     readonly is: ComputedRef<boolean>;
 }
 
-import { ApiInstance, ApiData, ApiDataValidation, ApiErrorStorageList } from '@dxtmisha/functional-basic';
-
+import { type ApiInstance, type ApiData, type ApiDataValidation, type ApiErrorStorageList } from '@dxtmisha/functional-basic';
 /**
- * Asynchronous reactive composable for API requests with built-in SSR support.
- * @keywords api, async, ssr, request, fetch
+ * Asynchronous reactive composable for API requests with built-in SSR pre-fetching support.
+ * @keywords api, composable, ssr, prefetch, useApiAsyncRef, useApiRef, reactive, fetch
+ * @example
+ * ```typescript
+ * const { data, loading, errorItem } = useApiAsyncRef('/users/1', { method: 'GET' });
+ * ```
+ * @param path Request path (string, Ref, or Getter)
+ * @param options Request options and headers
+ * @param reactivity Auto-refetch when reactive dependencies change
+ * @param conditions Execution conditions (waits until true)
+ * @param transformation Transforms received response data
+ * @param validateResponseContract Validates response data contract
+ * @param errorContract Predefined expected error contracts
+ * @param unmounted Aborts request and clears cache when component unmounts
+ * @param apiInstance Custom Api instance
  */
 export declare function useApiAsyncRef<R, T = R>(path?: RefOrNormal<string | undefined>, options?: ApiOptions, reactivity?: boolean, conditions?: RefType<boolean>, transformation?: (data: T, isResponseContractValid?: ApiDataValidation) => ApiData<R>, validateResponseContract?: (data: T) => ApiDataValidation, errorContract?: ApiErrorStorageList, unmounted?: boolean, apiInstance?: ApiInstance): UseApiRef<R>;
 
-import { ApiData, ApiFetch } from '@dxtmisha/functional-basic';
-import { Ref } from 'vue';
-
+import { type ApiData, type ApiFetch } from '@dxtmisha/functional-basic';
 export interface UseApiDeleteSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
 }
-
-/**
- * Executes a DELETE request via the API.
- * @keywords api delete request setup composable
- */
+/** Wrapper over `useApiRequest` pre-configured for DELETE HTTP requests. @keywords api, delete, fetch, request, http */
 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>;
+    loading: import("vue").Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
 
-/** Setup interface for API GET request @keywords api get setup request configuration */
+import { type ApiData, type ApiFetch } from '@dxtmisha/functional-basic';
+/** Setup options for API GET request. @keywords api, get, request, setup */
 export interface UseApiGetSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
 }
-
-/** Executes an API GET request with loading state and send method @keywords api get request wrapper */
+/** Wrapper over `useApiRequest` pre-configured for GET requests. @keywords api, get, fetch, request, query */
 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>;
+    loading: import("vue").Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
 
-import { ApiInstance, ArrayToItem, FormattersListColumns, FormattersOptionsList, SearchColumns, ApiDataValidation, SearchFormatList, ApiData, ApiErrorItem, ApiFetch } from '@dxtmisha/functional-basic';
-import { ComputedRef, Ref } from 'vue';
-
-/**
- * Asynchronous reactive composable for API management requests with SSR support.
- * @keywords api management async ssr composable fetch
- */
+import { type ApiInstance, type ArrayToItem, type FormattersListColumns, type FormattersOptionsList, type SearchColumns } from '@dxtmisha/functional-basic';
+/** Asynchronous reactive composable for API management requests with SSR prefetching. @keywords api, management, ssr, reactive, fetch, composable */
 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>;
+    isValid: import("vue").ComputedRef<boolean>;
+    isResponseContractValid: import("vue").ComputedRef<boolean>;
+    responseValidationResult: import("vue").ComputedRef<import("@dxtmisha/functional-basic").ApiDataValidation | undefined>;
+    list: import("vue").ComputedRef<import("@dxtmisha/functional-basic").SearchFormatList<ItemFormatters, Columns>>;
+    readonly data: import("vue").ComputedRef<import("@dxtmisha/functional-basic").ApiData<Return> | undefined>;
+    errorItem: import("vue").ComputedRef<import("@dxtmisha/functional-basic").ApiErrorItem | undefined>;
+    readonly length: import("vue").ComputedRef<number>;
+    lengthData: import("vue").ComputedRef<number>;
+    starting: import("vue").ComputedRef<boolean>;
+    reading: import("vue").Ref<boolean, boolean>;
+    loading: import("vue").Ref<boolean, boolean>;
+    loadingSearch: import("vue").Ref<boolean, boolean> | undefined;
+    loadingPost: import("vue").Ref<boolean, boolean> | undefined;
+    loadingPut: import("vue").Ref<boolean, boolean> | undefined;
+    loadingDelete: import("vue").Ref<boolean, boolean> | undefined;
+    isSearch: import("vue").ComputedRef<boolean> | undefined;
+    search: import("vue").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>;
+    sendPost: (request?: import("@dxtmisha/functional-basic").ApiFetch["request"]) => Promise<import("@dxtmisha/functional-basic").ApiData<Post> | undefined>;
+    sendPut: (request?: import("@dxtmisha/functional-basic").ApiFetch["request"]) => Promise<import("@dxtmisha/functional-basic").ApiData<Put> | undefined>;
+    sendDelete: (request?: import("@dxtmisha/functional-basic").ApiFetch["request"]) => Promise<import("@dxtmisha/functional-basic").ApiData<Delete> | undefined>;
 };
 
-import { Ref, ComputedRef } from 'vue';
-import { FormattersOptionsList, ApiData, ApiInstance, ArrayToItem, SearchColumns, SearchFormatList, FormattersListColumns, ApiFetch, ApiDataValidation, ApiErrorItem, ApiManagementValue, ApiManagementGet, ApiManagementSearch, ApiManagementRequest } from '@dxtmisha/functional-basic';
+import { type ComputedRef, type Ref } from 'vue';
+import {
+  type ApiData,
+  type ApiDataValidation,
+  type ApiErrorItem,
+  type ApiFetch,
+  type ApiInstance,
+  type ArrayToItem,
+  type FormattersListColumns,
+  type FormattersOptionsList,
+  type SearchColumns,
+  type SearchFormatList
+} from '@dxtmisha/functional-basic';
 
 /**
- * Manages API requests and list operations.
- * @keywords api, management, ref, request
+ * Orchestrates API requests, data loading (GET), list formatting, client-side search, and mutations (POST, PUT, DELETE).
+ * @note Recommended for use with `executeUse` for centralized state management.
+ * @remarks
+ * Data formatting guidelines for `formattersOptions`:
+ * - Recommended: values (prices, counts), dates, currency, units, statuses.
+ * - Not recommended: technical identifiers (ID, UUID, internal codes).
+ * @example
+ * const products = useApiManagementRef(
+ *   { path: '/api/v1/products', skeleton: () => Array(5).fill({ id: 0, name: 'Loading...', price: 0 }) },
+ *   { price: (v) => `${v} USD`, created_at: (v) => new Date(v).toLocaleDateString() },
+ *   { columns: ['name', 'category'] },
+ *   { path: '/api/v1/products' },
+ *   { path: (data) => `/api/v1/products/${data.id}` },
+ *   { path: (data) => `/api/v1/products/${data.id}` }
+ * );
+ * @keywords api, management, fetch, mutations, search, formatters, reactive
  */
-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>;
-    /** Initializes api management. @keywords init, start */
-    init: () => void;
-    /** Initializes server-side rendering. @keywords ssr, init */
-    initSsr: () => void;
-    /** Resets request state. @keywords reset, clear */
-    reset: () => Promise<void>;
-    /** Aborts active request. @keywords abort, cancel */
-    abort: () => void;
-    /** Sends POST request. @keywords post, send */
-    sendPost: (request?: ApiFetch["request"]) => Promise<ApiData<Post> | undefined>;
-    /** Sends PUT request. @keywords put, send */
-    sendPut: (request?: ApiFetch["request"]) => Promise<ApiData<Put> | undefined>;
-    /** Sends DELETE request. @keywords delete, send */
-    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
+): {
+  /** Whether data passed type verification check. @keywords valid, validation */
+  isValid: ComputedRef<boolean>;
+  /** Status of response contract validation. @keywords contract, validation */
+  isResponseContractValid: ComputedRef<boolean>;
+  /** Result of response schema validation. @keywords response, validation, result */
+  responseValidationResult: ComputedRef<ApiDataValidation | undefined>;
+  /** Processed data array with skeleton, formatters, and search applied. @keywords list, formatted, search */
+  list: ComputedRef<SearchFormatList<ItemFormatters, Columns>>;
+  /** Raw reactive response data. @keywords raw data, response */
+  readonly data: ComputedRef<ApiData<Return> | undefined>;
+  /** Current request error item. @keywords error */
+  errorItem: ComputedRef<ApiErrorItem | undefined>;
+  /** Current number of items in filtered list. @keywords length, count */
+  readonly length: ComputedRef<number>;
+  /** Total number of items in raw data. @keywords total length, raw count */
+  lengthData: ComputedRef<number>;
+  /** Initial loading flag before data is first fetched. @keywords starting, initial load */
+  starting: ComputedRef<boolean>;
+  /** Active read operation flag. @keywords reading, fetching */
+  reading: Ref<boolean, boolean>;
+  /** Loading state for the main GET request. @keywords loading, state */
+  loading: Ref<boolean, boolean>;
+  /** Loading state during search processing. @keywords search loading */
+  loadingSearch: Ref<boolean, boolean> | undefined;
+  /** Loading state for POST mutation. @keywords post loading */
+  loadingPost: Ref<boolean, boolean> | undefined;
+  /** Loading state for PUT mutation. @keywords put loading */
+  loadingPut: Ref<boolean, boolean> | undefined;
+  /** Loading state for DELETE mutation. @keywords delete loading */
+  loadingDelete: Ref<boolean, boolean> | undefined;
+  /** Indicates whether search filter is active. @keywords is search, searching */
+  isSearch: ComputedRef<boolean> | undefined;
+  /** Reactive search query string proxy. @keywords search query */
+  search: Ref<string>;
+  /** Manually initializes API request. @keywords init, manual init */
+  init: () => void;
+  /** Initializes API request for SSR. @keywords ssr init */
+  initSsr: () => void;
+  /** Resets GET request and clears state. @keywords reset, reload */
+  reset: () => Promise<void>;
+  /** Aborts active network request. @keywords abort, cancel */
+  abort: () => void;
+  /** Executes POST mutation request. @keywords send post, create */
+  sendPost: (request?: ApiFetch['request']) => Promise<ApiData<Post> | undefined>;
+  /** Executes PUT mutation request. @keywords send put, update */
+  sendPut: (request?: ApiFetch['request']) => Promise<ApiData<Put> | undefined>;
+  /** Executes DELETE mutation request. @keywords send delete, remove */
+  sendDelete: (request?: ApiFetch['request']) => Promise<ApiData<Delete> | undefined>;
 };
 
-import { ApiData, ApiFetch } from '@dxtmisha/functional-basic';
-import { Ref } from 'vue';
-
-/**
- * Setup interface for API POST request.
- * @keywords api, post, setup, request
- */
+import { type ApiData, type ApiFetch } from '@dxtmisha/functional-basic';
 export interface UseApiPostSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
 }
-
-/**
- * Executes a POST request using the API.
- * @keywords api, post, request, send
- */
+/** Composable wrapper over useApiRequest pre-configured for HTTP POST requests. @keywords api, post, http, fetch, request */
 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>;
+    loading: import("vue").Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
 
-/** Setup interface for API PUT request @keywords useApiPutSetup, api, put */
-export interface UseApiPutSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
-}
-/** Use API PUT request wrapper @keywords useApiPut, api, put, request */
+import { type ApiData, type ApiFetch } from '@dxtmisha/functional-basic';
+
+export interface UseApiPutSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {}
+
+/** Setup and execute API PUT request with reactive loading state. @keywords api, put, request, fetch, http, vue */
 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>;
+    loading: import("vue").Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
 
-import { ComputedRef, Ref } from 'vue';
-import { ApiInstance, ApiData, ApiDataValidation, ApiErrorStorageList, ApiErrorItem } from '@dxtmisha/functional-basic';
+import { type ComputedRef, type Ref } from 'vue';
+import { type ApiInstance, type ApiData, type ApiDataValidation, type ApiErrorStorageList, ApiErrorItem, type ApiOptions, type RefOrNormal, type RefType } from '@dxtmisha/functional-basic';
 
 export interface UseApiRef<R> {
-	/** @keywords data, computed, reactive */
-	data: ComputedRef<ApiData<R> | undefined>;
-	/** @keywords item, ref */
-	item: Ref<ApiData<R> | undefined>;
-	/** @keywords error, computed, item */
-	errorItem: ComputedRef<ApiErrorItem | undefined>;
-	/** @keywords response, contract, valid, status */
-	isResponseContractValid: ComputedRef<boolean>;
-	/** @keywords response, validation, result */
-	responseValidationResult: ComputedRef<ApiDataValidation | undefined>;
-	/** @keywords length, computed */
-	length: ComputedRef<number>;
-	/** @keywords starting, flag */
-	starting: ComputedRef<boolean>;
-	/** @keywords loading, ref */
-	loading: Ref<boolean>;
-	/** @keywords reading, ref */
-	reading: Ref<boolean>;
-	/** @keywords is, starting */
-	isStarting(): boolean;
-	/** @keywords is, loading */
-	isLoading(): boolean;
-	/** @keywords is, reading */
-	isReading(): boolean;
-	/** @keywords get, item */
-	getItem(): ApiData<R> | undefined;
-	/** @keywords init */
-	init(): void;
-	/** @keywords init, ssr */
-	initSsr(): void;
-	/** @keywords reset */
-	reset(): Promise<void>;
-	/** @keywords stop */
-	stop(): void;
-	/** @keywords abort */
-	abort(): void;
+    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>;
+    /** Checks if the request is starting @keywords starting, status */
+    isStarting(): boolean;
+    /** Checks if the request is currently loading @keywords loading, status */
+    isLoading(): boolean;
+    /** Checks if the request is currently reading @keywords reading, status */
+    isReading(): boolean;
+    /** Gets current item data @keywords data, get */
+    getItem(): ApiData<R> | undefined;
+    /** Performs manual request initialization @keywords init, start */
+    init(): void;
+    /** Performs SSR request initialization @keywords ssr, init */
+    initSsr(): void;
+    /** Resets request state and data @keywords reset */
+    reset(): Promise<void>;
+    /** Stops the active request @keywords stop */
+    stop(): void;
+    /** Aborts the active request @keywords abort, cancel */
+    abort(): void;
 }
 
-/** @keywords api, ref, vue, composable */
+/**
+ * Main reactive composable for working with API requests in Vue, handling reactivity, SSR, caching, validation, and error management.
+ * @keywords api, fetch, request, composable, vue, query
+ * @example
+ * ```typescript
+ * const { data, loading, errorItem } = useApiRef('/users/1', { method: 'GET' });
+ * ```
+ * @param path Request endpoint path, Ref, or getter
+ * @param options Request options (headers, method, body, etc.)
+ * @param reactivity Automatically re-fetch when reactive dependencies change
+ * @param conditions Execution conditions (request waits until evaluated to true)
+ * @param transformation Transforms received response data
+ * @param validateResponseContract Validates response data contract
+ * @param errorContract Predefined error contracts for error handling
+ * @param unmounted Stops request and clears cached data when component unmounts
+ * @param apiInstance Custom Api instance
+ */
 export declare function useApiRef<R, T = R>(path?: RefOrNormal<string | undefined>, options?: ApiOptions, reactivity?: boolean, conditions?: RefType<boolean>, transformation?: (data: T, isResponseContractValid?: ApiDataValidation) => ApiData<R>, validateResponseContract?: (data: T) => ApiDataValidation, errorContract?: ApiErrorStorageList, unmounted?: boolean, apiInstance?: ApiInstance): UseApiRef<R>;
 
-/** @keywords set, api, global, conditions */
+/**
+ * Defines global conditions for executing API requests.
+ * @keywords api, global, conditions
+ * @param conditions Conditions evaluated before request execution
+ */
 export declare const setApiRefGlobalConditions: (conditions: RefType<any>) => void;
 
-import { ApiInstance, ApiMethodItem, ApiData, ApiFetch, ApiErrorStorageList, ApiDataValidation } from '@dxtmisha/functional-basic';
-import { Ref } from 'vue';
+import { type ApiInstance, ApiMethodItem, type ApiData, type ApiFetch, type ApiErrorStorageList, type ApiDataValidation } from '@dxtmisha/functional-basic';
 
-/** Setup interface for API request. @keywords useApiRequest setup api request configuration */
+/** API request setup configuration options. @keywords api, request, setup, options */
 export interface UseApiRequestSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> {
-    /** Path to the API endpoint. @keywords path endpoint api */
+    /** Endpoint path or reactive ref. */
     path?: RefOrNormal<string | undefined>;
-    /** HTTP method used for the request. @keywords method http get post */
+    /** HTTP method. Defaults to POST. */
     method?: ApiMethodItem;
-    /** Action callback after successful completion. @keywords action callback success */
+    /** Callback executed upon successful request completion. */
     action?: (data: Return | undefined) => Promise<void> | void;
-    /** Transformation function for response data. @keywords transformation transform response data */
+    /** Transforms raw response data before returning. */
     transformation?: (data: T) => Return;
-    /** Function to validate the request payload contract. @keywords validate request contract payload */
+    /** Validates request payload contract. */
     validateRequestContract?: (data: Request) => ApiDataValidation & Return;
-    /** Function to validate response data contract. @keywords validate response contract schema */
+    /** Validates response data contract. */
     validateResponseContract?: (data: T) => ApiDataValidation & Return;
-    /** Array of expected error contracts for the request. @keywords error contract list */
+    /** Expected error contracts list for centralized handling. */
     errorContract?: ApiErrorStorageList;
-    /** If true, extracts nested data field. @keywords toData extract response data */
+    /** Extracts nested 'data' field from response envelope. Defaults to true. */
     toData?: boolean;
-    /** Additional request options. @keywords options request headers params */
+    /** Additional request options. */
     options?: ApiOptions;
-    /** Custom Api instance. @keywords apiInstance custom api */
+    /** Custom Api instance. Defaults to global singleton. */
     apiInstance?: ApiInstance;
 }
 
-/** Execute an API request with loading states. @keywords useApiRequest request api fetch */
+/** Composable for managing and executing API requests with loading state. @keywords api, request, fetch, composable */
 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 state flag. @keywords loading state ref */
-    loading: Ref<boolean, boolean>;
-    /** Send the API request. @keywords send request api method */
+    /** Reactive loading state indicator. */
+    loading: import("vue").Ref<boolean, boolean>;
+    /** Executes the API request. @keywords send, execute, call */
     send(request?: Request): Promise<Return | undefined>;
 };
 
-import { Ref } from 'vue';
+import { type Ref } from 'vue';
 
 type BroadcastValueItem<T> = T | string | undefined;
 
-/**
- * Creates a reactive variable to manage data between browser tabs.
- * @keywords broadcast value ref tabs reactive
- * @param name value name
- * @param defaultValue default value
- */
+/** Creates a reactive ref synchronized across browser tabs. @param name Channel/storage key name @param defaultValue Initial value or factory function @keywords broadcast channel sync cross tab reactive state */
 export declare function useBroadcastValueRef<T>(name: string, defaultValue?: T | string | (() => (T | string))): Ref<BroadcastValueItem<T>>;
 
-export {};
-
-import { Ref } from 'vue';
-import { CookieOptions } from '@dxtmisha/functional-basic';
-
-/**
- * Creates a reactive variable to manage cookies.
- * @keywords cookie, ref, reactive, storage, useCookieRef
- */
+import { type Ref } from 'vue';
+import { type CookieOptions } from '@dxtmisha/functional-basic';
+/** Creates a reactive Vue ref synchronized with browser cookies. @param name Cookie name @param defaultValue Initial fallback value or getter function @param options Cookie configuration options @keywords cookie reactive state storage vue ref useCookieRef */
 export declare function useCookieRef<T>(name: string, defaultValue?: T | string | (() => (T | string)), options?: CookieOptions): Ref<T | string | undefined>;
 
-import { FormattersListProp, FormattersOptionsList, FormattersReturn } from '@dxtmisha/functional-basic';
-import { ComputedRef } from 'vue';
+import { type FormattersListProp, type FormattersOptionsList, type FormattersReturn } from '@dxtmisha/functional-basic';
 
-/**
- * Reactively formats a list of data based on provided formatting options.
- * @keywords useFormattersRef formatters list reactive
- */
+/** Reactively formats data lists based on property rules. @keywords format, list, reactive, transform */
 export declare function useFormattersRef<Options extends FormattersOptionsList = FormattersOptionsList, List extends FormattersListProp = FormattersListProp>(list: RefType<List | undefined>, options: Options): {
-    /** Formatted data list. @keywords list format computed */
-    listFormat: ComputedRef<FormattersReturn<List, Options>>;
-    /** Count of records in the formatted list. @keywords length count list */
-    length: ComputedRef<number>;
+    /** Formatted reactive data list. @keywords formatted list */
+    listFormat: import("vue").ComputedRef<FormattersReturn<List, Options>>;
+    /** Total count of records in the list. @keywords length, count */
+    length: import("vue").ComputedRef<number>;
 };
 
-/** Returns a class object for working with data formatting. @keywords geo intl format ref */
-export declare function useGeoIntlRef(): GeoIntlRef;
-
 /**
- * Returns a class object for working with unit formatting and automatic conversions.
- * @keywords useGeoUnitRef, geo, unit, formatting, conversion
+ * Returns a reactive instance for working with internationalization and data formatting.
+ * @remarks Avoid using this reactive composable if reactive updates are not required; use non-reactive `GeoIntl` instead.
+ * @keywords geointl, intl, format, localization, i18n, reactive
  */
-export declare function useGeoUnitRef(): GeoUnitRef;
+export declare function useGeoIntlRef(): GeoIntlRef;
 
-import { ShallowRef } from 'vue';
+/** Provides unit formatting and automatic conversion reference. @keywords geo unit conversion format measurement */
+export declare function useGeoUnitRef(): GeoUnitRef;
 
-/**
- * Creates a reactive variable to manage the hash.
- * @keywords useHashRef hash reactive variable state url
- * @param name value name
- * @param defaultValue default value
- */
+import { type ShallowRef } from 'vue';
+/** Creates a reactive shallow reference synchronized with the URL hash. @keywords hash reactive url state shallowRef */
 export declare function useHashRef<T>(name: string, defaultValue?: T | (() => T)): ShallowRef<T>;
 
 export type LazyItemByMargin = {
     rootMargin: string;
     item: ReturnType<typeof useLazyRef>;
 };
-/**
- * Hook for tracking element visibility by margin.
- * @keywords useLazyItemByMarginRef, lazy, observer, margin
- */
+/** Initializes element visibility tracking based on root margin. @keywords lazy loading, intersection observer, viewport, margin tracking */
 export declare const useLazyItemByMarginRef: (element: RefType<HTMLElement | undefined>, rootMargin?: string) => {
-    /** Lazy item status */
-    lazyItemStatus: ShallowRef<boolean, boolean>;
-    /** Tracked lazy item instance */
+    /** Lazy item visibility status. */
+    lazyItemStatus: import("vue").ShallowRef<boolean, boolean>;
+    /** Tracked lazy item instance. */
     readonly lazyItem: LazyItem | undefined;
 };
 
-import { Ref, ShallowRef } from 'vue';
-
+import { type Ref, type ShallowRef } from 'vue';
 export type LazyItem = {
     status: ShallowRef<boolean>;
     ratio: ShallowRef<number>;
     entry: ShallowRef<IntersectionObserverEntry | undefined>;
     stopWatch: () => void;
 };
-
 export type LazyList = Record<string, LazyItem>;
-
-/**
- * Initializes lazy reference tracking using Intersection Observer.
- * @keywords useLazyRef, lazy, observer, intersection, ref
- */
+/** Initializes tracking of element visibility using IntersectionObserver. @keywords intersection observer, lazy loading, visibility tracking, viewport */
 export declare const useLazyRef: (options?: IntersectionObserverInit) => {
     intersectionObserver: IntersectionObserver | undefined;
-    /**
-     * Gets lazy item by element.
-     * @keywords getItem, lazy, element
-     */
+    /** Retrieves tracked state for an element. @keywords get lazy item, tracking state */
     getItem(element?: HTMLElement): LazyItem | undefined;
-    /**
-     * Adds an element for lazy tracking.
-     * @keywords addLazyItem, lazy, track
-     */
+    /** Registers an element for visibility tracking and returns its visibility status ref. @keywords add lazy item, observe, viewport visibility */
     addLazyItem(element: Ref<HTMLElement | undefined>): ShallowRef<boolean, boolean>;
-    /**
-     * Removes an element from lazy tracking.
-     * @keywords removeLazyItem, lazy, remove
-     */
+    /** Removes a specific element from tracking. @keywords remove lazy item, unobserve */
     removeLazyItem: (element?: HTMLElement) => void;
-    /**
-     * Disconnects lazy observer.
-     * @keywords disconnectLazy, lazy, observer
-     */
+    /** Disconnects the observer and removes all tracked elements. @keywords disconnect, stop observing, clear lazy items */
     disconnectLazy: () => void | undefined;
 };
 
-import { ShallowRef } from 'vue';
-
-/**
- * Returns the global loading status reference.
- * @keywords useLoadingRef, loading, status, ref
- */
-export declare function useLoadingRef(): ShallowRef<boolean, boolean>;
+/** Returns a shallow reactive reference for the loading status. @keywords loading state, shallow ref, progress, status */
+export declare function useLoadingRef(): import("vue").ShallowRef<boolean, boolean>;
 
-import { MetaRobots, Meta } from '@dxtmisha/functional-basic';
+import { Meta, MetaRobots } from '@dxtmisha/functional-basic';
 import { Ref } from 'vue';
 
-/**
- * Vue composable for reactive meta tags management.
- * @keywords use_meta meta tags management seo vue
- */
+/** Reactive meta tag management composable with automatic DOM synchronization. @keywords useMeta, meta, seo, head, open graph */
 export declare const useMeta: () => Readonly<{
     meta: Meta;
     title: Ref<string, string>;
@@ -1071,33 +765,34 @@ export declare const useMeta: () => Readonly<{
     canonical: Ref<string, string>;
     robots: Ref<MetaRobots, MetaRobots>;
     siteName: Ref<string, string>;
-    /** Generates HTML string for all meta tags. @keywords get_html_meta ssr */
+    /** Generates HTML string for all meta tags for SSR. @keywords ssr, html, meta */
     getHtmlMeta: () => string;
-    /** Synchronizes reactive values with MetaStatic. @keywords sync meta */
+    /** Synchronizes reactive state with current MetaStatic state. @keywords sync, meta */
     sync: () => void;
-    /** Updates MetaStatic values with current reactive state. @keywords update meta */
+    /** Updates MetaStatic values with current reactive state. @keywords update, meta */
     update: () => void;
-    /** Updates MetaStatic values in SSR environment. @keywords update ssr */
+    /** Updates MetaStatic values in SSR environments. @keywords ssr, update */
     updateSsr: () => void;
-    /** Sets the page title. @keywords set title */
+    /** Sets the page title. @keywords title, seo */
     setTitle: (value: string) => void;
-    /** Sets the keywords meta tag. @keywords set keywords */
+    /** Sets the keywords meta tag. @keywords keywords, seo */
     setKeywords: (value: string) => void;
-    /** Sets the description meta tag. @keywords set description */
+    /** Sets the description meta tag. @keywords description, seo */
     setDescription: (value: string) => void;
-    /** Sets the author meta tag. @keywords set author */
+    /** Sets the author meta tag. @keywords author, meta */
     setAuthor: (value: string) => void;
-    /** Sets the Open Graph / Twitter Card image URL. @keywords set image */
+    /** Sets Open Graph and Twitter Card image URL. @keywords image, og, twitter */
     setImage: (value: string) => void;
-    /** Sets the canonical URL. @keywords set canonical */
+    /** Sets the canonical URL. @keywords canonical, url */
     setCanonical: (value: string) => void;
-    /** Sets the robots meta tag directive. @keywords set robots */
+    /** Sets the robots meta tag directive. @keywords robots, indexing */
     setRobots: (value: MetaRobots) => void;
-    /** Sets the site name for Open Graph and Twitter Card. @keywords set site name */
+    /** Sets site name for Open Graph and Twitter Card. @keywords siteName, og, twitter */
     setSiteName: (value: string) => void;
-    /** Sets the suffix for the page title. @keywords set suffix */
+    /** Sets suffix for the page title. @keywords suffix, title */
     setSuffix: (suffix: string) => void;
-} & {
+}> & {
+    /** Initializes meta manager instance. @keywords init, meta */
     init(): Readonly<{
         meta: Meta;
         title: Ref<string, string>;
@@ -1108,450 +803,477 @@ export declare const useMeta: () => Readonly<{
         canonical: Ref<string, string>;
         robots: Ref<MetaRobots, MetaRobots>;
         siteName: Ref<string, string>;
-        /** Generates HTML string for all meta tags. @keywords get_html_meta ssr */
+        /** Generates HTML string for all meta tags for SSR. @keywords ssr, html, meta */
         getHtmlMeta: () => string;
-        /** Synchronizes reactive values with MetaStatic. @keywords sync meta */
+        /** Synchronizes reactive state with current MetaStatic state. @keywords sync, meta */
         sync: () => void;
-        /** Updates MetaStatic values with current reactive state. @keywords update meta */
+        /** Updates MetaStatic values with current reactive state. @keywords update, meta */
         update: () => void;
-        /** Updates MetaStatic values in SSR environment. @keywords update ssr */
+        /** Updates MetaStatic values in SSR environments. @keywords ssr, update */
         updateSsr: () => void;
-        /** Sets the page title. @keywords set title */
+        /** Sets the page title. @keywords title, seo */
         setTitle: (value: string) => void;
-        /** Sets the keywords meta tag. @keywords set keywords */
+        /** Sets the keywords meta tag. @keywords keywords, seo */
         setKeywords: (value: string) => void;
-        /** Sets the description meta tag. @keywords set description */
+        /** Sets the description meta tag. @keywords description, seo */
         setDescription: (value: string) => void;
-        /** Sets the author meta tag. @keywords set author */
+        /** Sets the author meta tag. @keywords author, meta */
         setAuthor: (value: string) => void;
-        /** Sets the Open Graph / Twitter Card image URL. @keywords set image */
+        /** Sets Open Graph and Twitter Card image URL. @keywords image, og, twitter */
         setImage: (value: string) => void;
-        /** Sets the canonical URL. @keywords set canonical */
+        /** Sets the canonical URL. @keywords canonical, url */
         setCanonical: (value: string) => void;
-        /** Sets the robots meta tag directive. @keywords set robots */
+        /** Sets the robots meta tag directive. @keywords robots, indexing */
         setRobots: (value: MetaRobots) => void;
-        /** Sets the site name for Open Graph and Twitter Card. @keywords set site name */
+        /** Sets site name for Open Graph and Twitter Card. @keywords siteName, og, twitter */
         setSiteName: (value: string) => void;
-        /** Sets the suffix for the page title. @keywords set suffix */
+        /** Sets suffix for the page title. @keywords suffix, title */
         setSuffix: (suffix: string) => void;
     }>;
-    /** Destroys execution context. @keywords destroy execute */
+    /** Cleans up meta watchers and listeners. @keywords cleanup, destroy */
     destroyExecute?(): void;
-}>;
+};
 
-import { ShallowRef } from 'vue';
+import { type ShallowRef } from 'vue';
 
-/**
- * Creates a reactive variable to manage URL query parameters.
- * @keywords query parameter url ref reactive
- * @param name Parameter name
- * @param defaultValue Default value
- */
+/** Creates a reactive shallow ref synchronized with a URL query parameter. @keywords vue, query, url, search params, reactive ref */
 export declare function useQueryRef<T>(name: string, defaultValue?: T | (() => T)): ShallowRef<T>;
 
-import { Ref, ComputedRef } from 'vue';
-import { NumberOrString } from '@dxtmisha/functional-basic';
+import { type ComputedRef, type Ref } from 'vue';
+import { type NumberOrString } from '@dxtmisha/functional-basic';
 
-/**
- * Managing a list of links for the router.
- * @keywords useRouterList router links navigation
- */
+/** Manages a list of router navigation links and selection state. @keywords router list navigation route */
 export declare const useRouterList: <T extends ListDataBasic>(list: RefType<ConstrBind<T>[] | undefined>, selected?: Ref<string> | string, hasTo?: boolean) => {
-    /** Active router item / Активный элемент роутера */
     item: ComputedRef<T | undefined>;
-    /** Selected element / Выбранный элемент */
+    /** Selected item identifier. */
     selected: Ref<string, string>;
-    /** Label of selected element / Метка выбранного элемента */
     label: ComputedRef<NumberOrString>;
-    /** List of elements / Список элементов */
+    /** Processed router link elements list. */
     list: ComputedRef<ConstrBind<T>[]>;
-    /** Navigate by name / Переход по имени */
+    /** Navigates to the target route item by name. @keywords navigate route to */
     to: (name?: string) => void;
-    /** Transition to the main element / Переход к главному элементу */
+    /** Navigates to the main root element. @keywords navigate main home route */
     toMain(): void;
 };
 
-import { Ref, ComputedRef } from 'vue';
-import { SearchColumns, SearchFormatList, SearchItem, SearchOptions } from '@dxtmisha/functional-basic';
-
-/**
- * Composable for handling search logic with reactive data.
- * @keywords search ref reactive list columns
- */
+import { type ComputedRef, type Ref } from 'vue';
+import { type SearchColumns, type SearchFormatList, type SearchItem, type SearchOptions } from '@dxtmisha/functional-basic';
+/** Composable for managing reactive search logic, match highlights, and loading status. @keywords vue search filter reactive useSearchRef */
 export declare function useSearchRef<T extends SearchItem, K extends SearchColumns<T>>(list: SearchListInput<T>, columns?: SearchColumnsInput<T, K>, value?: Ref<string>, options?: SearchOptions): {
-    /** Whether search is currently active. @keywords isSearch active */
+    /** Whether search is currently active and meets character threshold. @keywords isSearch active */
     isSearch: ComputedRef<boolean>;
-    /** Search string reference. @keywords search string */
+    /** Reactive search query string reference. @keywords search query */
     search: Ref<string, string>;
-    /** Search loading status reference. @keywords loading status */
+    /** Search loading status during delayed execution. @keywords loading status */
     loading: Ref<boolean, boolean>;
-    /** Formatted search results list. @keywords list search results */
+    /** Formatted list of search results with match highlights. @keywords listSearch results highlight */
     listSearch: ComputedRef<SearchFormatList<T, K>>;
-    /** Length of search results. @keywords length count */
+    /** Total count of matching search results. @keywords length count */
     length: ComputedRef<number>;
 };
 
-import { Ref } from 'vue';
-import { SearchList, SearchColumns, SearchItem } from '@dxtmisha/functional-basic';
+import { type Ref } from 'vue';
+import { SearchList, type SearchColumns, type SearchItem } from '@dxtmisha/functional-basic';
 
-/**
- * Manages search value state and handling delays.
- * @keywords useSearchValueRef, search, delay, debounce, loading
- */
+/** Manages search query state, debounce delay, and loading status. @keywords search, query, debounce, delay, loading, search list */
 export declare function useSearchValueRef<T extends SearchItem, K extends SearchColumns<T>>(item: SearchList<T, K>, value?: Ref<string>): {
     /** Current search value */
     search: Ref<string, string>;
-    /** Search value with applied delay */
+    /** Search value with applied debounce delay */
     searchDelay: Ref<string, string>;
-    /** Loading status during delay */
+    /** Loading state during debounce delay */
     loading: Ref<boolean, boolean>;
 };
 
-import { Ref } from 'vue';
+import { type Ref } from 'vue';
 
-/**
- * Creates a reactive variable for session storage.
- * @keywords session ref storage reactive
- */
+/** Creates a reactive ref synchronized with sessionStorage. @keywords session storage, reactive ref, useSessionRef, vue */
 export declare function useSessionRef<T>(name: string, defaultValue?: T | (() => T)): Ref<T | undefined>;
 
-import { Ref } from 'vue';
-
-/**
- * Creates a reactive reference to manage browser local storage.
- * @keywords storage, local, reactive, ref
- */
+import { type Ref } from 'vue';
+/** Creates a reactive ref synchronized with local storage. @keywords storage, localstorage, reactive, ref, state, cache */
 export declare function useStorageRef<T>(name: string, defaultValue?: T | (() => T), cache?: number): Ref<T | undefined>;
 
-import { ShallowRef } from 'vue';
-import { TranslateInstance, TranslateList } from '@dxtmisha/functional-basic';
-
+import { type ShallowRef } from 'vue';
+import { type TranslateInstance, type TranslateList } from '@dxtmisha/functional-basic';
 /**
- * Gets translated text by key or array of keys.
- * @keywords translate ref localization i18n
+ * Returns a reactive ShallowRef of translated texts for given keys, auto-updating on locale change.
+ * @example const translations = useTranslateRef(['home.title', 'home.description'] as const);
+ * @keywords translate translation i18n vue composable shallowRef reactive
  */
 export declare function useTranslateRef<T extends (string | string[])[]>(names: T, translateInstance?: TranslateInstance): ShallowRef<TranslateList<T>>;
-
-/**
- * Shorthand alias for useTranslateRef.
- * @keywords translate t localization i18n shorthand
- */
+/** Shorthand for `useTranslateRef`. @keywords translate i18n t vue composable */
 export declare const t: <T extends string[]>(names: T) => ShallowRef<TranslateList<T>>;
 
-```ts
-/** Initializes user interface flags. @keywords ui, flags, initialize */
+/** Initializes UI flags configuration. @keywords ui, flags, make flags */
 export declare const uiMakeFlags: () => void;
-```
 
 export * from '@dxtmisha/functional-basic';
 
-import { ComputedRef, DebuggerOptions } from 'vue';
-
-/**
- * Creates a computed property that handles asynchronous getters.
- * @keywords computed async reactive vue
- */
+import { type ComputedRef, type DebuggerOptions } from 'vue';
+/** Creates a reactive computed property that supports asynchronous getters, initial states, and ignored values. @keywords computedAsync, async computed, vue reactivity, promise computed */
 export declare function computedAsync<R>(getter: (() => Promise<R>) | (() => R) | R, initialState?: (() => R) | R, ignore?: R, debugOptions?: DebuggerOptions): ComputedRef<R | undefined>;
 
-import { ComputedGetter, ComputedRef, DebuggerOptions } from 'vue';
-
-/**
- * Creates a language-dependent computed reactive property.
- * @keywords computed language reactive getter
- */
+import { type ComputedGetter, type ComputedRef, type DebuggerOptions } from 'vue';
+/** Creates a reactive computed property evaluated based on language and conditions, with fallback support. @keywords computed, i18n, language, localization, reactive, fallback */
 export declare function computedByLanguage<T, R extends (T | undefined) = T | undefined>(getter: ComputedGetter<R>, getterNone?: R | (() => R), conditions?: () => boolean, debugOptions?: DebuggerOptions): ComputedRef<R>;
 
-/** Computes eternity property on demand with caching @keywords computed eternity cache async */
+import { type Ref } from 'vue';
+
+/** Creates a cached on-demand computed property with a persistent watcher active for the entire application lifecycle. @keywords computed, lazy, cache, persistent, watcher */
 export declare function computedEternity<T>(getter: () => Promise<T> | T, initialState?: (() => T) | T): Ref<T, T>;
 
-import { Plugin } from 'vue';
-import { InputSocialIcons } from '@dxtmisha/media';
-import { ApiConfig, ErrorCenterCauseList, ErrorCenterHandlerCallback, ErrorCenterHandlerList, IconsConfig, TranslateConfig } from '@dxtmisha/functional-basic';
-import { Router } from 'vue-router';
+import { type Plugin } from 'vue';
+import { type InputSocialIcons } from '@dxtmisha/media';
+import { type ApiConfig, type ErrorCenterCauseList, type ErrorCenterHandlerCallback, type ErrorCenterHandlerList, type IconsConfig, type TranslateConfig } from '@dxtmisha/functional-basic';
+import type { Router } from 'vue-router';
 
+/** Options for configuring the functional plugin. @keywords plugin, options, config */
 export interface FunctionalPluginOptions {
+    /** Configuration for the API client. */
     api?: ApiConfig;
+    /** Configuration for the translation service. */
     translate?: TranslateConfig;
+    /** Default geographical location or language code. */
     location?: string | (() => string);
+    /** Suffix appended to all page titles. */
     metaSuffix?: string;
+    /** Configuration for the icon management service. */
     icons?: IconsConfig;
+    /** Configuration for the social icons service. */
     iconsSocial?: InputSocialIcons;
+    /** Vue Router instance for navigation state management. */
     router?: Router;
+    /** Error causes list for error center. */
     errorCauses?: ErrorCenterCauseList;
+    /** Error handlers list for error center. */
     errorHandlers?: ErrorCenterHandlerList;
+    /** Global error callback functions for error center. */
     errorCallbacks?: ErrorCenterHandlerCallback[];
 }
 
 /**
- * Vue plugin for initializing and configuring global functional services.
- * @keywords plugin, dxtFunctionalPlugin, functional, vue
+ * Vue plugin for initializing and configuring global functional services (API, Translate, Icons, Meta).
+ * @keywords vue, plugin, api, translate, icons, meta, error-center
  * @example
- * import { createApp } from 'vue'
- * import { dxtFunctionalPlugin } from '@dxtmisha/functional'
- * const app = createApp(App)
- * app.use(dxtFunctionalPlugin, { api: { url: 'https://api.example.com' } })
+ * ```typescript
+ * import { createApp } from 'vue';
+ * import { dxtFunctionalPlugin } from '@dxtmisha/functional';
+ * import router from './router';
+ *
+ * const app = createApp(App);
+ * app.use(dxtFunctionalPlugin, {
+ *   api: { url: 'https://api.example.com' },
+ *   metaSuffix: ' | My App',
+ *   router
+ * });
+ * ```
  */
 export declare const dxtFunctionalPlugin: Plugin;
 
-/** Types of initialization for a singleton @keywords execute, use, type */
 export declare enum ExecuteUseType {
-    /** Global application instance @keywords global, singleton */
     global = "global",
-    /** Provide/inject shared instance @keywords provide, inject */
     provide = "provide",
-    /** Local closure instance @keywords local, closure */
     local = "local"
 }
 
 export type ExecuteUseReturn<R> = Readonly<R & {
-    /** Returns raw instance @keywords init, raw */
+    /** Returns the raw instance without management methods. @keywords init, unwrap */
     init(): Readonly<R>;
-    /** Resets cached instance @keywords destroy, reset */
+    /** Resets the cached instance for local and global strategies. @keywords reset, destroy, cache */
     destroyExecute?(): void;
 }>;
 
 /**
- * Creates a managed singleton with initialization strategies.
- * @keywords execute, use, singleton, factory
+ * Creates a managed singleton encapsulating initialization logic and access strategy.
+ * @keywords singleton, provide-inject, global-state, factory, cache
+ * @remarks
+ * Supports three initialization strategies:
+ * - `global`: Single instance across the entire application.
+ * - `provide`: Shared via provide/inject in the component hierarchy.
+ * - `local`: Single instance scoped to the returned function closure.
+ * @example
+ * 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);
 
 /**
- * Creates a global singleton.
- * @keywords execute, use, global, singleton
+ * Creates an application-wide global singleton.
+ * @keywords global, singleton, shared-instance
+ * @remarks See {@link executeUse} for more details.
  */
 export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<R & {
+    /** Returns the raw instance without management methods. @keywords init, unwrap */
     init(): Readonly<R>;
+    /** Resets the cached instance for local and global strategies. @keywords reset, destroy, cache */
     destroyExecute?(): void;
 }>) | (() => Readonly<R & {
+    /** Returns the raw instance without management methods. @keywords init, unwrap */
     init(): Readonly<R>;
+    /** Resets the cached instance for local and global strategies. @keywords reset, destroy, cache */
     destroyExecute?(): void;
 }>);
 
 /**
- * Creates a component-scoped singleton.
- * @keywords execute, use, provide, singleton
+ * Creates a component-tree scoped singleton using provide/inject.
+ * @keywords provide, inject, vue, scoped-state
+ * @remarks Best for sharing state within a component sub-tree. See {@link executeUse}.
  */
 export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
+    /** Returns the raw instance without management methods. @keywords init, unwrap */
     init(): Readonly<R>;
+    /** Resets the cached instance for local and global strategies. @keywords reset, destroy, cache */
     destroyExecute?(): void;
 }>) | (() => Readonly<R & {
+    /** Returns the raw instance without management methods. @keywords init, unwrap */
     init(): Readonly<R>;
+    /** Resets the cached instance for local and global strategies. @keywords reset, destroy, cache */
     destroyExecute?(): void;
 }>);
 
 /**
- * Creates a local singleton.
- * @keywords execute, use, local, singleton
+ * Creates a closure-scoped local singleton.
+ * @keywords local, singleton, closure, memoize
+ * @remarks Best for preserving internal state within a closure. See {@link executeUse}.
  */
 export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
+    /** Returns the raw instance without management methods. @keywords init, unwrap */
     init(): Readonly<R>;
+    /** Resets the cached instance for local and global strategies. @keywords reset, destroy, cache */
     destroyExecute?(): void;
 }>) | (() => Readonly<R & {
+    /** Returns the raw instance without management methods. @keywords init, unwrap */
     init(): Readonly<R>;
+    /** Resets the cached instance for local and global strategies. @keywords reset, destroy, cache */
     destroyExecute?(): void;
 }>);
 
-/**
- * Initializes all global callbacks.
- * @keywords execute, use, global, init
- */
+/** Initializes all registered global singleton callbacks. @keywords initialize, bootstrap, global-init */
 export declare function executeUseGlobalInit(): void;
 
-/**
- * Get injected value by name.
- * @keywords get_inject dependency injection
- */
+/** Retrieves an injected value by its key name. @keywords inject dependency injection di container get */
 export declare function getInject<T>(name: string): T | undefined;
 
-/** Get request options. @keywords get_options request api */
+import type { ApiFetch } from '@dxtmisha/functional-basic';
+/** Gets request options for API fetch calls. @keywords request, options, api, fetch */
 export declare const getOptions: (options?: ApiOptions) => RefOrNormal<ApiFetch>;
 
-/**
- * Executes a function if provided and unwraps the resulting Vue Ref.
- * @keywords execute, function, ref, unwrap, reactive
- */
+/** Executes a function or unwraps a Vue ref or raw value to resolve its underlying value. @keywords execute, unwrap, ref, getter, reactive */
 export declare function executeFunctionRef<T>(data: RefOrNormalOrFunction<T>): T;
 
-import { ComputedRef } from 'vue';
-import { ApiData, ApiErrorItem } from '@dxtmisha/functional-basic';
+import { type ComputedRef } from 'vue';
+import { type ApiData, type ApiErrorItem } from '@dxtmisha/functional-basic';
 
-/**
- * Returns the error item for the Api ref.
- * @keywords api error ref reactive getApiErrorRef
- */
+/** Returns a computed ref containing the API error item. @keywords api, error, ref, computed */
 export declare function getApiErrorRef<R>(data: RefType<ApiData<R> | undefined>): ComputedRef<ApiErrorItem | undefined>;
 
-import { ComputedRef } from 'vue';
-import { ItemList } from '@dxtmisha/functional-basic';
+import { type ComputedRef } from 'vue';
+import type { ItemList } from '@dxtmisha/functional-basic';
 
-/**
- * Generates a computed reference for subcomponent bindings.
- * @keywords get_bind_ref reactive properties computed binding
- */
+/** Generates reactive bound properties for a subcomponent. @keywords subcomponent, props binding, computed ref */
 export declare function getBindRef<T, R extends ItemList>(value: RefOrNormal<T | R> | undefined, nameExtra?: RefOrNormal<ItemList> | string, name?: string): ComputedRef<R>;
 
-/** Returns the value of a reactive ref or the value itself if not reactive. @keywords get ref value unwrap */
+/** Unwraps a ref or returns the value directly if not reactive. @keywords unref, ref, reactive, unwrap */
 export declare function getRef<T>(item: RefOrNormal<T>): T;
 
-import { VNode } from 'vue';
-import { ItemList } from '@dxtmisha/functional-basic';
+import { type VNode } from 'vue';
+import type { ItemList } from '@dxtmisha/functional-basic';
 
-/** Render virtual node with cached properties. @keywords render, vnode, components */
+/** Renders and caches immutable VNode component structures. @keywords render, vnode, component, cache */
 export declare function render<T extends ItemList>(name: string | any, props?: T, children?: RawChildren | RawSlots, index?: string): VNode;
 
-import { Ref } from 'vue';
+import { type Ref } from 'vue';
 
-/**
- * Changes the value of a reactive reference.
- * @keywords set ref value update
- */
+/** Updates the value of a Vue Ref. @keywords vue ref reactivity set update */
 export declare function setRef<T>(item: Ref<T>, value: T): void;
 
-/**
- * Returns a reference or wraps the value in a reference.
- * @keywords ref toRefItem wrap reactive variable
- */
+import { type Ref } from 'vue';
+/** Converts a value or ref into a Vue Ref. @keywords vue, ref, toRef, reactivity */
 export declare function toRefItem<T>(item: RefOrNormal<T>): Ref<T>;
 
-/**
- * Generates component binding properties.
- * @keywords getBind bind properties component attributes
- */
+import { type ItemList } from '@dxtmisha/functional-basic';
+/** Generates binding properties for a subcomponent. @keywords bind, props, subcomponent, generate */
 export declare function getBind<T, R extends ItemList>(value: T | R | undefined | null, nameExtra?: ItemList | string, name?: string, except?: boolean): ConstrBind<R>;
 
-/**
- * Returns the class name from the provided properties object.
- * @keywords get class name props
- */
-export declare function getClassName<T extends ItemList>(props?: T): string | undefined;
+import type { ItemList } from '@dxtmisha/functional-basic';
 
-import { ItemList } from '@dxtmisha/functional-basic';
+/** Returns the class name from component properties. @keywords get class name, props, class extraction */
+export declare function getClassName<T extends ItemList>(props?: T): string | undefined;
 
-/**
- * Returns or generates a render index string.
- * @keywords render, index, key, generator
- */
+import { type ItemList } from '@dxtmisha/functional-basic';
+/** Resolves or generates a unique key index for rendering a component item. @keywords render index, component key, unique key */
 export declare function getIndexForRender<T extends ItemList>(name: string | any, props?: T, index?: string): string | undefined;
 
-/**
- * Merges two objects with properties, taking into account their classes and styles
- * @keywords toBind merge objects class style bind
- */
+import type { ItemList } from '@dxtmisha/functional-basic';
+
+/** Merges two property objects, combining their classes and styles. @keywords merge objects, classes, styles, bind properties */
 export declare function toBind<R extends ItemList = ItemList>(extra: ItemList, value: ItemList): ConstrBind<R>;
 
-/** Merges multiple objects into a single bound object with combined classes and styles. @keywords toBinds merge bind styles classes */
+import type { ItemList } from '@dxtmisha/functional-basic';
+/** Merges multiple objects with properties, intelligently combining their classes and styles. @keywords merge binds classes styles */
 export declare function toBinds<R extends ItemList = ItemList>(...values: (ItemList | undefined)[]): ConstrBind<R>;
 
-
-
+import type { ApiData, ApiDataValidation, ApiDefaultValue, ApiErrorStorageList, ApiFetch, ApiMethodItem, SearchColumns, SearchItem, SearchOptions } from '@dxtmisha/functional-basic';
+import type { Ref } from 'vue';
 export type ApiOptions = ApiMethodItem | RefOrNormal<ApiFetch>;
 export type ApiManagementValue = ApiDefaultValue | ApiDefaultValue[];
+/** Configuration for GET requests in API management @keywords api, get, fetch, request */
 export type ApiManagementGet<Return extends ApiManagementValue, Type extends ApiManagementValue = Return> = {
+    /** API endpoint path */
     path?: RefOrNormal<string | undefined>;
+    /** Additional request options */
     options?: ApiOptions;
+    /** Enables reactive refetching on path or options change */
     reactivity?: boolean;
+    /** Condition required to trigger the request */
     conditions?: RefType<boolean>;
+    /** Custom transformation applied to fetched data */
     transformation?: (data: Type, isResponseContractValid?: ApiDataValidation) => ApiData<Return>;
+    /** Validates the response data contract */
     validateResponseContract?: (data: Type) => ApiDataValidation;
+    /** Storage of response error contracts */
     errorContract?: ApiErrorStorageList;
+    /** Validation function or constructor type for data */
     typeData?: ((data: Return) => boolean) | any;
+    /** Clears data on component unmount */
     unmounted?: boolean;
+    /** Provides skeleton placeholder data during loading */
     skeleton?: () => Return;
 };
+/** Configuration for client-side search across API data @keywords api, search, filter */
 export type ApiManagementSearch<T extends SearchItem, K extends SearchColumns<T>> = {
+    /** Columns to search through */
     columns: K;
+    /** Reactive search query string */
     value?: Ref<string>;
+    /** Search algorithm configuration */
     options?: SearchOptions;
 };
+/** Configuration for mutation requests (POST, PUT, DELETE) @keywords api, mutation, request, post, put, delete */
 export type ApiManagementRequest<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> = {
+    /** Target API endpoint path */
     path?: RefOrNormal<string | undefined>;
+    /** Callback executed after successful request */
     action?: (data: Return | undefined) => Promise<void> | void;
+    /** Transformation applied before sending data */
     transformation?: (data: T) => Return;
+    /** Request contract validation function */
     validateRequestContract?: (data: Request) => ApiDataValidation & Return;
+    /** Response contract validation function */
     validateResponseContract?: (data: T) => ApiDataValidation & Return;
+    /** Storage of response error contracts */
     errorContract?: ApiErrorStorageList;
+    /** Wraps payload into a `data` property */
     toData?: boolean;
+    /** Additional mutation request options */
     options?: ApiOptions;
 };
 
+import type { Ref, PropType, ComputedRef } from 'vue';
+import type { Undefined } from '@dxtmisha/functional-basic';
+
 export type ConstrItem = Record<string, any>;
+
 export type ConstrValue<T = any> = {
-    value?: T;
+  value?: T;
 };
+
 export type ConstrComponent = Record<string, any>;
+
+/** Constructor component modification type with reactive or normal values. @keywords component, modifier, reactive */
 export type ConstrComponentMod<P extends ConstrItem> = ConstrItem | {
-    [K in keyof P]?: RefOrNormal<P[K]>;
+  [K in keyof P]?: RefOrNormal<P[K]>;
 };
+
 export type ConstrExpose<E extends Element, EXPOSE extends ConstrItem> = EXPOSE & {
-    elementHtml?: ComputedRef<E | undefined>;
+  elementHtml?: ComputedRef<E | undefined>;
 };
+
+/** Converts union types to intersection types. @keywords union, intersection, utility */
 export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
 export type ConstrEmitItem<T extends ConstrItem> = T[keyof T];
+
+/** Constructor emit type generating strongly-typed event handler signatures. @keywords emit, events, handler */
 export type ConstrEmit<T extends ConstrItem = ConstrItem> = UnionToIntersection<ConstrEmitItem<{
-    [K in keyof T]: (evt: K, ...args: T[K]) => void;
+  [K in keyof T]: (evt: K, ...args: T[K]) => void;
 }>>;
+
 export type ConstrClassObject = Record<string, boolean | undefined>;
+
 export type ConstrClass = string | (string | ConstrClass | Undefined)[] | ConstrClassObject;
+
 export type ConstrClassList = Record<string, ConstrClass>;
+
 export type ConstrClasses = {
-    main: ConstrClass;
+  main: ConstrClass;
 } & ConstrClassList;
+
 export type ConstrStylesItem = string | null;
+
 export type ConstrStyles = Record<string, ConstrStylesItem> | ConstrStyles[];
-/** Constructor options for component configuration @keywords options setup component */
+
+/** Constructor options interface for component configuration. @keywords options, configuration */
 export type ConstrOptions<COMP extends ConstrComponent, EMITS extends ConstrItem, P extends ConstrItem> = {
-    components?: COMP;
-    compMod?: ConstrComponentMod<P>;
-    emits?: ConstrEmit<EMITS>;
-    classes?: RefType<ConstrClasses>;
-    styles?: RefType<ConstrStyles>;
+  components?: COMP;
+  compMod?: ConstrComponentMod<P>;
+  emits?: ConstrEmit<EMITS>;
+  classes?: RefType<ConstrClasses>;
+  styles?: RefType<ConstrStyles>;
 };
-/** Constructor setup structure for component initialization @keywords setup initialization */
+
+/** Constructor setup interface for component initialization. @keywords setup, initialize */
 export type ConstrSetup<E extends Element, CLASSES extends ConstrClasses, SETUP extends ConstrItem> = {
-    name: string;
-    element: Ref<E | undefined>;
-    classes: RefType<CLASSES>;
-    styles: RefType<ConstrStyles>;
+  name: string;
+  element: Ref<E | undefined>;
+  classes: RefType<CLASSES>;
+  styles: RefType<ConstrStyles>;
 } & SETUP;
+
 export type ConstrRegistration = {
-    flag?: boolean;
-    translate?: Record<string, string>;
+  flag?: boolean;
+  translate?: Record<string, string>;
 };
-/** Constructor bind type with class and style support @keywords bind attributes */
-export type ConstrBind<T> = T & Record<string, any> & {
-    key?: string;
-    class?: ConstrClass;
-    style?: ConstrStyles;
+
+/** Constructor binding type supporting element attributes, classes, and styles. @keywords bind, template, attributes */
+export type ConstrBind<T = ConstrItem> = T & Record<string, any> & {
+  key?: string;
+  class?: ConstrClass;
+  style?: ConstrStyles;
 };
+
+/** Constructor prop item options for Vue prop definitions. @keywords prop, options, vue */
 export type ConstrPropItemOptions<T = any> = {
-    type?: PropType<T>;
-    required?: boolean;
-    default?: any;
-    validator?(value: any, props: any): boolean;
+  type?: PropType<T>;
+  required?: boolean;
+  default?: any;
+  /** Validates the provided prop value. @keywords validator, prop */
+  validator?(value: any, props: any): boolean;
 };
+
 export type ConstrPropItem<T = any> = ConstrPropItemOptions<T> | PropType<T>;
+
 export type ConstrProps<P = Record<string, any>> = {
-    [K in keyof P]: ConstrPropItem<P[K]>;
+  [K in keyof P]: ConstrPropItem<P[K]>;
 };
-/** Hyperlink props definition @keywords href link properties */
+
 export type ConstrHrefProps = {
-    href?: string;
+  href?: string;
 };
 
-import { NumberOrString, NumberOrStringOrBoolean } from '@dxtmisha/functional-basic';
+import type { NumberOrString, NumberOrStringOrBoolean } from '@dxtmisha/functional-basic';
 
-/** Type of list item @keywords list, type, item */
+/** Type of list item @keywords list, type, item, space, line, subtitle, html, menu, group */
 export type ListType = 'item' | 'space' | 'line' | 'subtitle' | 'html' | 'menu' | 'menu-group' | 'group';
 
-/** Basic data structure for list item @keywords list, data, basic */
+/** Basic data structure for list item @keywords list, data, basic, record */
 export type ListDataBasic = {
     label?: NumberOrString;
     value?: any;
     search?: string;
 };
 
-/** Extended list item with type and index @keywords list, item, extended */
+/** Extended list item with type and index @keywords list, data, item, index, parent */
 export type ListDataItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item & {
     parent?: string;
     type: ListType;
@@ -1559,13 +1281,11 @@ export type ListDataItem<Item extends ListDataBasic = ListDataBasic> = ConstrBin
     disabled?: boolean;
 }>;
 
-/** Array of list data items @keywords list, items, array */
 export type ListList<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item>[];
 
-/** List or record structure for list data @keywords list, record, structure */
 export type ListRecord<Item extends ListDataBasic = ListDataBasic> = Item[] | Record<string, Item>;
 
-/** Extended list item with additional state properties @keywords list, item, full, state */
+/** Extended list item with additional state properties @keywords list, item, focus, highlight, selected */
 export type ListDataFullItem<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item> & {
     focus: boolean;
     highlight?: string;
@@ -1573,74 +1293,43 @@ export type ListDataFullItem<Item extends ListDataBasic = ListDataBasic> = ListD
     disabled?: boolean;
 };
 
-/** Array of extended list items with state @keywords list, data, full, state */
 export type ListDataFull<Item extends ListDataBasic = ListDataBasic> = ListDataFullItem<Item>[];
 
-/** Input item for list creation @keywords list, input, item */
 export type ListListInputItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item>;
 
-/** Various input formats for list creation @keywords list, input, formats */
+/** Various input formats for list creation @keywords list, input, format, record */
 export type ListListInput<Item extends ListDataBasic = ListDataBasic> = ListListInputItem<Item>[] | string[] | Record<string, ListListInputItem<Item>> | Record<string, string>;
 
-/** Single selected item identifier @keywords list, selected, item */
 export type ListSelectedItem = NumberOrStringOrBoolean;
 
-/** Single or multiple selected items @keywords list, selected, list */
 export type ListSelectedList = ListSelectedItem | ListSelectedItem[];
 
-/** Name of selected list item @keywords list, name */
 export type ListName = string | number | undefined;
 
-/** Array of list item names @keywords list, names, array */
 export type ListNames = ListName[];
 
-import { ComputedRef, Ref, VNode, VNodeArrayChildren } from 'vue';
+import { type ComputedRef, type Ref, type VNode, type VNodeArrayChildren } from 'vue';
 
-/**
- * Union type for Vue reactive references (computed or ref)
- * @keywords ref type computed reactive
- */
+/** Vue reactive reference (Ref or ComputedRef). @keywords vue ref computed */
 export type RefType<T> = ComputedRef<T> | Ref<T>;
-
-/**
- * Union type for Vue reactive references that can be undefined
- * @keywords ref undefined computed reactive
- */
+/** Vue reactive reference that can be undefined. @keywords vue ref undefined */
 export type RefUndefined<T> = RefType<T | undefined>;
-
-/**
- * Union type that can be either a Vue reactive reference or a normal value
- * @keywords ref normal value reactive
- */
+/** Vue reactive reference or raw unwrapped value. @keywords vue ref value */
 export type RefOrNormal<T> = RefType<T> | T;
-
-/**
- * Union type that can be a Vue reactive reference, normal value, or function returning them
- * @keywords ref normal function reactive
- */
+/** Vue reactive reference, raw value, or getter function. @keywords vue ref getter */
 export type RefOrNormalOrFunction<T> = RefOrNormal<T> | (() => RefOrNormal<T>);
-
-/**
- * Union type for Vue raw children content
- * @keywords raw children vnode array
- */
+/** Vue raw children content (primitives, VNodes, array, or render function). @keywords vue vnode children */
 export type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
-
-/**
- * Type for Vue raw slots with optional stability flag
- * @keywords raw slots stable vue
- */
+/** Vue raw slots definition with optional stability flag. @keywords vue slots */
 export type RawSlots = {
     [name: string]: unknown;
+    /** Stability flag for slot optimization. @keywords vue slot stable */
     $stable?: boolean;
 };
 
-import { SearchColumns, SearchItem, SearchListValue } from '@dxtmisha/functional-basic';
-/** Search list value reference @keywords search list value ref */
+import type { SearchColumns, SearchItem, SearchListValue } from '@dxtmisha/functional-basic';
+
 export type SearchListValueRef<T extends SearchItem> = RefOrNormal<SearchListValue<T>>;
-/** Search list input configuration @keywords search list input */
 export type SearchListInput<T extends SearchItem> = SearchListValueRef<T> | (() => SearchListValueRef<T>);
-/** Search columns reference @keywords search columns ref */
 export type SearchColumnsRef<T extends SearchItem, K extends SearchColumns<T>> = RefOrNormal<K>;
-/** Search columns input configuration @keywords search columns input */
 export type SearchColumnsInput<T extends SearchItem, K extends SearchColumns<T>> = SearchColumnsRef<T, K> | (() => SearchColumnsRef<T, K>);