@dxtmisha/functional 1.15.9 → 1.15.13

package/ai-types.md

@@ -1,320 +1,761 @@
-All these methods are in the @dxtmisha/functional library.
+All these methods are in the @dxtmisha/functional (v1.15.13) library.
 
-/** Base class for working with the constructor. */
+/** Base class for working with design component constructors. @keywords design abstract constructor callback */
 export declare abstract class DesignAbstract<T extends Record<string, any>, C extends Record<string, any>> {
-    protected readonly callback?: ((event: C) => void) | undefined;
+    /** Constructor @keywords design constructor initialize */
     constructor(props: T, callback?: ((event: C) => void) | undefined, changed?: string[]);
+    /** Calls the callback function. @keywords design make update */
     make(compelled?: boolean): this;
-    protected is<K extends keyof T>(name: K): boolean;
-    protected isChanged<K extends keyof C & string, KT extends keyof T & string>(name: K, nameProp?: KT | KT[]): boolean;
+    /** Calls the callback function. @keywords design callback */
     makeCallback(compelled?: boolean): void;
-    protected makeCallbackItem(): void;
-    protected abstract initEvent(): void;
 }
-/**
+
+/** Base class for asynchronous design construction. @keywords design async abstract class */
 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 */
     make(compelled?: boolean): this;
+    /** Makes callback asynchronously. @keywords make callback async */
     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 */
 export declare class DesignChanged<T extends Record<string, any>> {
+    /** Creates a changed tracker instance. @keywords constructor create */
     constructor(props: T, watch?: string[]);
+    /** Checks if property changed. @keywords is changed check */
     is(name: string | string[]): boolean;
+    /** Checks if any watched property changed. @keywords is changed */
     isChanged(): boolean;
+    /** Updates cached property values. @keywords update cache */
     update(): void;
-    protected isDifferent(name: string): boolean;
 }
-export declare class DesignComp<COMP extends ConstrComponent, P extends ConstrItem> extends DesignComponents<COMP, P> {}
+
+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 */
 export declare class DesignComponents<COMP extends ConstrComponent, P extends ConstrItem> {
+    /** Creates a component manager instance. @keywords constructor design components */
     constructor(components?: COMP, modification?: ConstrComponentMod<P> | undefined);
+    /** Checks if a component exists by name. @keywords check component exists */
     is<K extends keyof COMP>(name: K): name is K;
+    /** Retrieves a component by name. @keywords get component */
     get<K extends keyof COMP>(name: K): COMP[K];
+    /** Computes and returns modified component properties. @keywords get modification props */
     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 */
     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 */
     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 */
     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 */
 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 */
     getName(): string;
+    /** Gets design prefix/name. @keywords get design */
     getDesign(): string;
+    /** Gets sub-class name by levels. @keywords get sub class */
     getSubClass(name: string | string[]): string;
+    /** Gets status modifier class name. @keywords get status class */
     getStatusClass(name: string | string[]): string;
+    /** Gets CSS custom property name. @keywords get style var */
     getStyle(name: string | string[]): string;
+    /** Gets filtered element attributes. @keywords get attrs */
     getAttrs(): ConstrItem;
+    /** Exposes public component properties and element. @keywords expose component */
     expose(): ConstrExpose<E, EXPOSE>;
+    /** Returns component render function. @keywords render function */
     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';
+
+/** @keywords DatetimeRef, date, reactive, time */
 export declare class DatetimeRef {
+    /** @keywords constructor, init */
     constructor(date: RefOrNormal<NumberOrStringOrDate>, type?: RefOrNormal<GeoDate>, code?: RefOrNormal<string>);
+    /** @keywords getItem, date, ref */
     getItem(): Ref<NumberOrStringOrDate>;
+    /** @keywords getDate, date */
     getDate(): Ref<Date>;
+    /** @keywords getDatetime, datetime */
     getDatetime(): Datetime;
+    /** @keywords getHoursType, hours */
     getHoursType(): ComputedRef<GeoHours>;
+    /** @keywords getFirstDayCode, firstDay */
     getFirstDayCode(): ComputedRef<GeoFirstDay>;
+    /** @keywords getYear, year */
     getYear(): ComputedRef<number>;
+    /** @keywords getMonth, month */
     getMonth(): ComputedRef<number>;
+    /** @keywords getDay, day */
     getDay(): ComputedRef<number>;
+    /** @keywords getHour, hour */
     getHour(): ComputedRef<number>;
+    /** @keywords getMinute, minute */
     getMinute(): ComputedRef<number>;
+    /** @keywords getSecond, second */
     getSecond(): ComputedRef<number>;
+    /** @keywords getMaxDay, maxDay */
     getMaxDay(): ComputedRef<number>;
+    /** @keywords locale, format */
     locale(type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions): ComputedRef<string>;
+    /** @keywords standard, format */
     standard(timeZone?: boolean): ComputedRef<string>;
     protected updateDate(): this;
 }
+
+/** Global effect scope class. @keywords effect scope global scope */
 export declare class EffectScopeGlobal {
+    /** Runs a function within the global scope. @keywords run execute global 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';
+
 /**
- * Class for working with events (Ref).
- *
- * Класс для работа с события (Ref).
+ * Class for working with events using reactive references.
+ * @keywords event_ref event_wrapper reactive_event dom_event
  */
 export declare class EventRef<E extends ElementOrWindow, O extends Event, D extends Record<string, any> = Record<string, any>> extends EventItem<E, O, D> {
     /**
-     * Classes Constructor
-     * @param elementSelector element/ элемент
-     * @param elementSelectorControl control element/ элемент управления
-     * @param type type/ тип
-     * @param listener the object that receives a notification (an object that implements the
-     * Event interface) when an event of the specified type occurs/ объект, который принимает
-     * уведомление, когда событие указанного типа произошло
-     * @param options object that specifies characteristics/ объект options
-     * @param detail an event-dependent value associated with the event/ зависимое от события
-     * значение, связанное с событием
+     * Creates an instance of EventRef.
+     * @keywords constructor event_ref_init
      */
     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';
+
+/** Geo flag reactive reference manager. @keywords geo, flag, country, language */
 export declare class GeoFlagRef {
+    /**
+     * Creates a new GeoFlagRef instance.
+     * @param code Country or language code
+     */
     constructor(code?: RefOrNormal<string | undefined>);
+    /** Gets the current country code. @keywords code, get */
     getCode(): string;
+    /** Gets reactive country flag item information. @keywords country, flag, item */
     get(code?: RefOrNormal<string>): ComputedRef<GeoFlagItem | undefined>;
+    /** Gets reactive language flag item information. @keywords language, flag, item */
     getLanguage(code?: RefOrNormal<string>): ComputedRef<GeoFlagItem | undefined>;
+    /** Gets reactive flag image URL or source. @keywords flag, link, image */
     getFlag(code?: RefOrNormal<string>): ComputedRef<string | undefined>;
+    /** Gets a reactive list of country flag items. @keywords list, country, flags */
     getList(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagItem[]>;
+    /** Gets a reactive list of language flag items. @keywords list, language, flags */
     getListLanguage(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagItem[]>;
+    /** Gets reactive country flag items in national representation. @keywords national, country, list */
     getNational(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
+    /** Gets reactive language flag items in national representation. @keywords national, language, list */
     getNationalLanguage(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
 }
+
+import { ComputedRef } from 'vue';
+import { GeoDate, ItemValue, NumberOrString, NumberOrStringOrDate } from '@dxtmisha/functional-basic';
+
 /**
  * Reactive class for managing the formatting of numbers and dates.
- * @remarks Avoid using this reactive class if reactive updates are not required. For non-reactive formatting, use the standard `GeoIntl` class from `@dxtmisha/functional-basic`.
+ * @keywords geo intl format reactive number date localize
  */
 export declare class GeoIntlRef {
+    /**
+     * Constructor for GeoIntlRef.
+     * @keywords constructor initialize geo intl ref
+     */
     constructor(code?: RefOrNormal<string>);
+
+    /**
+     * Format display names for language, region, and script.
+     * @keywords display name language region script intl
+     */
     display(value?: RefOrNormal<string>, typeOptions?: Intl.DisplayNamesOptions['type'] | Intl.DisplayNamesOptions): ComputedRef<string>;
+
+    /**
+     * Get display names of language.
+     * @keywords language name translate intl
+     */
     languageName(value?: RefOrNormal<string>, style?: Intl.RelativeTimeFormatStyle): ComputedRef<string>;
+
+    /**
+     * Get display names of region.
+     * @keywords country region name intl
+     */
     countryName(value?: RefOrNormal<string>, style?: Intl.RelativeTimeFormatStyle): ComputedRef<string>;
+
+    /**
+     * Format a number value.
+     * @keywords number format intl digit
+     */
     number(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
+
+    /**
+     * Get the decimal point symbol.
+     * @keywords decimal point symbol separator
+     */
     decimal(): ComputedRef<string>;
+
+    /**
+     * Format a currency value.
+     * @keywords currency format money price intl
+     */
     currency(value: RefOrNormal<NumberOrString>, currencyOptions?: RefOrNormal<string | Intl.NumberFormatOptions>, numberOnly?: boolean): ComputedRef<string>;
+
+    /**
+     * Get the currency symbol or code.
+     * @keywords currency symbol code intl
+     */
     currencySymbol(currency: RefOrNormal<string>, currencyDisplay?: keyof Intl.NumberFormatOptionsCurrencyDisplayRegistry): ComputedRef<string>;
+
+    /**
+     * Format a unit value.
+     * @keywords unit format measurement intl
+     */
     unit(value: RefOrNormal<NumberOrString>, unitOptions?: string | Intl.NumberFormatOptions): ComputedRef<string>;
+
+    /**
+     * Format a file size value.
+     * @keywords size file bytes megabytes intl
+     */
     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
+     */
     percent(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
+
+    /**
+     * Format a number as a percentage by 100.
+     * @keywords percent 100 format intl
+     */
     percentBy100(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
+
+    /**
+     * Format text based on plural rules and language words.
+     * @keywords plural rules words format intl
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     month(value?: RefOrNormal<NumberOrStringOrDate>, style?: Intl.DateTimeFormatOptions['month']): ComputedRef<string>;
+
+    /**
+     * Get an array of all months.
+     * @keywords months list array intl
+     */
     months(style?: Intl.DateTimeFormatOptions['month']): ComputedRef<ItemValue<number | undefined>[]>;
+
+    /**
+     * Get the name of a weekday.
+     * @keywords weekday name date format intl
+     */
     weekday(value?: RefOrNormal<NumberOrStringOrDate>, style?: Intl.DateTimeFormatOptions['weekday']): ComputedRef<string>;
+
+    /**
+     * Get an array of all weekdays.
+     * @keywords weekdays list array intl
+     */
     weekdays(style?: Intl.DateTimeFormatOptions['weekday']): ComputedRef<ItemValue<number | undefined>[]>;
+
+    /**
+     * Format time.
+     * @keywords time format intl
+     */
     time(value: RefOrNormal<NumberOrStringOrDate>): ComputedRef<string>;
+
+    /**
+     * Sort an array of items taking into account locale specifics.
+     * @keywords sort locale array intl
+     */
     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 */
 export declare class GeoRef {
-    static get(): Ref<GeoItemFull>;
-    static getCountry(): ComputedRef<string>;
-    static getLanguage(): ComputedRef<string>;
-    static getStandard(): ComputedRef<string>;
-    static getFirstDay(): ComputedRef<string>;
-    static getLocation(): ComputedRef<string>;
-    static getLocationCountry(): ComputedRef<string>;
-    static getLocationLanguage(): ComputedRef<string>;
-    static set(code: string): void;
-    static setValueDefault(code?: string | (() => string)): void;
+	/** 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;
 }
+
+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
+ */
 export declare class GeoUnitRef {
+    /**
+     * Creates an instance of GeoUnitRef.
+     * @keywords constructor, geo, unit
+     */
     constructor(code?: RefOrNormal<string>);
+
+    /**
+     * Returns the standard location code.
+     * @keywords getLocation, location, code, standard
+     */
     getLocation(): ComputedRef<string>;
+
+    /**
+     * Formats millimeter value, converting to inches if overridden by locale unit settings.
+     * @keywords millimeter, format, length, unit
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+     */
     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
+ */
 export declare class ListDataRef {
+    /**
+     * Creates an instance of ListData for managing list data.
+     * @keywords list data constructor initialize
+     */
     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
+     */
     isLite(): boolean;
+    /**
+     * Checks if an element is in focus.
+     * @keywords is focus check
+     */
     isFocus(): boolean;
+    /**
+     * Checks if there is a highlighted item (search results).
+     * @keywords is highlight check search
+     */
     isHighlight(): boolean;
+    /**
+     * Checks if highlighting is active (minimum length reached).
+     * @keywords is highlight active check
+     */
     isHighlightActive(): boolean;
+    /**
+     * Returns the number of records in the current list.
+     * @keywords get length count list
+     */
     getLength(): number;
+    /**
+     * Returns the number of all available records in the map.
+     * @keywords get length map count
+     */
     getLengthByMap(): number;
+    /**
+     * Returns the number of all available records (items).
+     * @keywords get length items count
+     */
     getLengthByItems(): number;
+    /**
+     * Returns the identifier in focus.
+     * @keywords get focus identifier
+     */
     getFocus(): ListSelectedItem | undefined;
+    /**
+     * Returns the item in focus.
+     * @keywords get focus item data
+     */
     getFocusItem(): ListDataItem | undefined;
+    /**
+     * Returns the highlight text.
+     * @keywords get highlight search text
+     */
     getHighlight(): string | undefined;
+    /**
+     * Returns the minimum length for highlight to start.
+     * @keywords get highlight length start
+     */
     getHighlightLengthStart(): number;
+    /**
+     * Returns the selected identifiers list.
+     * @keywords get selected list
+     */
     getSelected(): ListSelectedList | undefined;
+    /**
+     * Returns an item by moving a certain number of steps from the selected item.
+     * @keywords get selected by step navigation
+     */
     getSelectedByStep(step: number): ListSelectedItem | undefined;
+    /**
+     * Returns the next item from the selected one.
+     * @keywords get selected next item
+     */
     getSelectedNext(): ListSelectedItem | undefined;
+    /**
+     * Returns the previous item from the selected one.
+     * @keywords get selected prev item
+     */
     getSelectedPrev(): ListSelectedItem | undefined;
+    /**
+     * Returns an item by moving a certain number of steps from the specified item.
+     * @keywords get item by step navigation
+     */
     getItemByStep(item: ListDataItem, step: number): ListDataItem | undefined;
+    /**
+     * Returns the next item from the specified one.
+     * @keywords get item next
+     */
     getItemNext(item: ListDataItem): ListDataItem | undefined;
+    /**
+     * Returns the previous item from the specified one.
+     * @keywords get 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
+     */
     getIndexByStep(index: string, step: number): ListDataItem | undefined;
+    /**
+     * Returns the next item from the specified index.
+     * @keywords get index next
+     */
     getIndexNext(index: string): ListDataItem | undefined;
+    /**
+     * Returns the previous item from the specified index.
+     * @keywords get index prev
+     */
     getIndexPrev(index: string): ListDataItem | undefined;
+    /**
+     * Returns an item by its index.
+     * @keywords get item by index
+     */
     getItemByIndex(index?: string): {
         key: number;
         item: ListDataItem;
     } | undefined;
+    /**
+     * Returns an item by its key.
+     * @keywords get item by key number
+     */
     getItemByKey(key: number): ListDataItem | undefined;
+    /**
+     * Returns the first item with the specified parent.
+     * @keywords get first item by parent
+     */
     getFirstItemByParent(parent: string | undefined): ListDataItem | undefined;
+    /**
+     * Returns the last item with the specified parent.
+     * @keywords get last item by parent
+     */
     getLastItemByParent(parent: string | undefined): ListDataItem | undefined;
+    /**
+     * Returns a sublist object for a group item.
+     * @keywords get sub list group item
+     */
     getSubList(item: ListDataItem): ListDataRef;
-    protected isItem(item: ListDataItem): boolean;
-    protected isInParent(parent: string | undefined, item: ListDataItem): boolean;
-    protected getIndex(index: string | number | undefined, value: any, key: string | number | undefined, label: string | number | undefined): string | number | undefined;
-    protected initItem(key: string | number, item: any): ListDataItem;
 }
+
+import { RouteLocationRaw, Router, _RouterClassic } from 'vue-router';
+
+/**
+ * Router management class.
+ * @keywords router, navigation, ref, link, href
+ */
 export declare class RouterItemRef {
-    static get(): _RouterClassic;
-    static getLink(name: string, params?: any, query?: any): string | undefined;
-    static getHref(name?: string, params?: any, query?: any): ConstrHrefProps;
-    static push(to: string | RouteLocationRaw): void;
-    static set(router: Router): void;
-    static setOneTime(router: Router): void;
-    static rawToHref(to?: string | RouteLocationRaw): ConstrHrefProps;
+	/** 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;
 }
+
+import { Ref, ComputedRef } from 'vue';
+
+/** Scrollbar width reactive reference utility class @keywords scrollbar, width, reactive, dom */
 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 */
     constructor();
+    /** Computes whether scrollbar width is available @keywords is, computed, check */
     readonly is: ComputedRef<boolean>;
 }
+
+import { ApiInstance, ApiData, ApiDataValidation, ApiErrorStorageList } from '@dxtmisha/functional-basic';
+
 /**
  * Asynchronous reactive composable for API requests with built-in SSR support.
- * Wraps `useApiRef` and immediately calls `initSsr()` to ensure data is pre-fetched on the server side.
- * Use this composable ONLY if you need the request to be executed on the server side during SSR.
- * For all other cases, use `useApiRef`.
- *
- * @example
- * ```typescript
- * import { Schema as S } from '@effect/schema'
- * import { useApiAsyncRef } from '@dxtmisha/functional'
- *
- * const userSchema = S.Struct({ id: S.Number, name: S.String })
- *
- * // Data will be pre-fetched on the server during SSR (onServerPrefetch)
- * const { data, loading, errorItem, isResponseContractValid } = useApiAsyncRef(
- *   '/users/1',
- *   { method: 'GET' },
- *   true, // reactivity
- *   undefined, // conditions
- *   undefined, // transformation
- *   (data) => { // validateResponseContract
- *     try {
- *       return { status: 'success', data: S.decodeUnknownSync(userSchema)(data) }
- *     } catch (e) {
- *       return { status: 'error', errors: e }
- *     }
- *   },
- *   [ // errorContract
- *     { status: 404, message: 'User not found' }
- *   ]
- * )
- * ```
+ * @keywords api, async, ssr, request, fetch
  */
 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';
+
 export interface UseApiDeleteSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
 }
+
 /**
- * Use API delete request.
- * This is a convenient wrapper over `useApiRequest` that pre-fills the DELETE method.
+ * Executes a DELETE request via the API.
+ * @keywords api delete request setup composable
  */
 export declare function useApiDelete<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiDeleteSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
+
+/** Setup interface for API GET request @keywords api get setup request configuration */
 export interface UseApiGetSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
 }
-/**
- * Use API get request.
- * This is a convenient wrapper over `useApiRequest` that pre-fills the GET method.
- */
+
+/** Executes an API GET request with loading state and send method @keywords api get request wrapper */
 export declare function useApiGet<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiGetSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
+
 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 built-in SSR support.
- * Wraps `useApiManagementRef` and immediately calls `initSsr()` to ensure data is pre-fetched on the server side.
- * Use this composable ONLY if you need the request to be executed on the server side during SSR.
- * For all other cases, use `useApiManagementRef`.
- *
- * Асинхронный реактивный composable для запросов управления API со встроенной поддержкой SSR.
- * Оборачивает `useApiManagementRef` и сразу вызывает `initSsr()`, чтобы гарантировать предзагрузку данных на сервере.
- * Используйте этот composable ТОЛЬКО если вам необходимо, чтобы запрос был выполнен на стороне сервера
- * во время SSR. Во всех остальных случаях используйте обычный `useApiManagementRef`.
- * @template Return type of data returned by the API / тип данных, возвращаемых API
- * @template FormattersOptions optional formatting rules / опциональные правила форматирования
- * @template Post data type for POST creation request / тип данных для POST-запроса создания
- * @template Put data type for PUT update request / тип данных для PUT-запроса обновления
- * @template Delete data type for DELETE removal request / тип данных для DELETE-запроса удаления
- * @template Type original data type (before transformation) / тип исходных данных (до трансформации)
- * @template Item type of a single item in the data list / тип одного элемента из списка данных
- * @template ItemFormatters item type after formatters are applied / тип элемента после применения форматировщиков
- * @template Columns search columns derived from formatting / колонки, по которым производится поиск
- *
- * @param propsGet main GET request settings (path, reactivity, skeleton, etc.) / настройки главного GET-запроса
- * @param formattersOptions optional reactive formatting rules / правила для реактивного форматирования данных
- * @param searchOptions optional client-side search settings / настройки для клиентского поиска по списку
- * @param postRequest optional POST mutation settings / настройки для POST-запроса создания
- * @param putRequest optional PUT mutation settings / настройки для PUT-запроса обновления
- * @param deleteRequest optional DELETE mutation settings / настройки для DELETE-запроса удаления
- * @param action common callback executed after any successful mutation / общий коллбэк после любой успешной мутации
- * @param apiInstance API instance for requests (defaults to Api.getItem()) / экземпляр API для выполнения запроса
+ * Asynchronous reactive composable for API management requests with SSR support.
+ * @keywords api management async ssr composable fetch
  */
 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>;
@@ -342,65 +783,13 @@ export declare function useApiManagementAsyncRef<Return extends ApiManagementVal
     sendPut: (request?: ApiFetch["request"]) => Promise< ApiData<Put> | undefined>;
     sendDelete: (request?: ApiFetch["request"]) => Promise< 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';
+
 /**
- * A powerful composable for comprehensive API request orchestration.
- * It centrally manages data loading (GET), list formatting, client-side searching,
- * and mutations (POST, PUT, DELETE) through a single reactive interface.
- *
- * @template Return type of data returned by the API
- * @template FormattersOptions optional formatting rules
- * @template Post data type for POST creation request
- * @template Put data type for PUT update request
- * @template Delete data type for DELETE removal request
- * @template Type original data type (before transformation)
- * @template Item type of a single item in the data list
- * @template ItemFormatters item type after formatters are applied
- * @template Columns search columns derived from formatting
- *
- * @param propsGet main GET request settings (path, reactivity, skeleton, etc.)
- * @param formattersOptions optional reactive formatting rules
- * @param searchOptions optional client-side search settings
- * @param postRequest optional POST mutation settings
- * @param putRequest optional PUT mutation settings
- * @param deleteRequest optional DELETE mutation settings
- * @param action common callback executed after any successful mutation
- * @param apiInstance API instance for requests (defaults to Api.getItem())
- *
- * @returns reactive API management interface
- *
- * @note This hook is recommended to be used in tandem with `executeUse` for centralized state management.
- * By wrapping `useApiManagementRef` in `executeUseProvide` or `executeUseGlobal`, you can ensure
- * a single source of truth across the component tree or the entire application.
- *
- * @remarks
- * Data formatting guidelines for `formattersOptions`:
- * - **Recommended for formatting:** Numbers that represent values (prices, counts), dates, currency, units, and statuses.
- * - **Not recommended for formatting:** Technical identifiers such as ID, UUID, account numbers (if used for logic), types, or internal codes.
- *
- * @example
- * // 1. Comprehensive API orchestration
- * const products = useApiManagementRef(
- *   {
- *     path: '/api/v1/products',
- *     skeleton: () => Array(5).fill({ id: 0, name: 'Loading...', price: 0 })
- *   },
- *   {
- *     // Formatters for display
- *     price: (v) => `${v} USD`,
- *     created_at: (v) => new Date(v).toLocaleDateString()
- *   },
- *   {
- *     // Client-side search setup
- *     columns: ['name', 'category']
- *   },
- *   { path: '/api/v1/products' }, // POST (create)
- *   { path: (data) => `/api/v1/products/${data.id}` }, // PUT (update)
- *   { path: (data) => `/api/v1/products/${data.id}` }  // DELETE (remove)
- * );
- *
- * // Accessing data:
- * // products.list.value -> processed, formatted, and searched list
- * // products.sendPost({ name: 'New Product', price: 100 }) -> execute mutation
+ * Manages API requests and list operations.
+ * @keywords api, management, ref, request
  */
 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>;
@@ -420,232 +809,257 @@ export declare function useApiManagementRef<Return extends ApiManagementValue, F
     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>;
 };
+
+import { ApiData, ApiFetch } from '@dxtmisha/functional-basic';
+import { Ref } from 'vue';
+
+/**
+ * Setup interface for API POST request.
+ * @keywords api, post, setup, request
+ */
 export interface UseApiPostSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
 }
+
 /**
- * Use API post request.
- * This is a convenient wrapper over `useApiRequest` that pre-fills the POST method.
+ * Executes a POST request using the API.
+ * @keywords api, post, request, send
  */
 export declare function useApiPost<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiPostSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
+
+/** 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.
- * This is a convenient wrapper over `useApiRequest` that pre-fills the PUT method.
- */
+/** Use API PUT request wrapper @keywords useApiPut, api, put, request */
 export declare function useApiPut<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiPutSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
+
+import { ComputedRef, Ref } from 'vue';
+import { ApiInstance, ApiData, ApiDataValidation, ApiErrorStorageList, ApiErrorItem } from '@dxtmisha/functional-basic';
+
 export interface UseApiRef<R> {
-    data: ComputedRef<ApiData<R> | undefined>;
-    item: Ref<ApiData<R> | undefined>;
-    errorItem: ComputedRef<ApiErrorItem | undefined>;
-    isResponseContractValid: ComputedRef<boolean>;
-    responseValidationResult: ComputedRef<ApiDataValidation | undefined>;
-    length: ComputedRef<number>;
-    starting: ComputedRef<boolean>;
-    loading: Ref<boolean>;
-    reading: Ref<boolean>;
-    isStarting(): boolean;
-    isLoading(): boolean;
-    isReading(): boolean;
-    getItem(): ApiData<R> | undefined;
-    init(): void;
-    initSsr(): void;
-    reset(): Promise<void>;
-    stop(): void;
-    abort(): void;
+	/** @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;
 }
-/**
- * Main reactive composable for working with API requests in Vue.
- * Automatically handles SSR, reactivity, caching, error storage, data validation, and transformation.
- *
- * @example
- * ```typescript
- * import { Schema as S } from '@effect/schema'
- * import { useApiRef } from '@dxtmisha/functional'
- *
- * // Define a schema using @effect/schema
- * const userSchema = S.Struct({ id: S.Number, name: S.String })
- *
- * const { data, loading, errorItem, isResponseContractValid } = useApiRef(
- *   '/users/1',
- *   { method: 'GET' },
- *   true, // reactivity
- *   undefined, // conditions
- *   (data) => ({ ...data, isTransformed: true }), // transformation
- *   (data) => { // validateResponseContract
- *     try {
- *       return { status: 'success', data: S.decodeUnknownSync(userSchema)(data) }
- *     } catch (e) {
- *       return { status: 'error', errors: e }
- *     }
- *   },
- *   [ // errorContract (ApiErrorStorageList)
- *     {
- *       status: 404,
- *       message: 'User not found'
- *     }
- *   ]
- * )
- * ```
- */
+
+/** @keywords api, ref, vue, composable */
 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>;
-/**
- * Defines global conditions for the API request.
- *
- * Определяет глобальные условия для API запроса.
- * @param conditions conditions for executing the request/ условия выполнения запроса
- */
+
+/** @keywords set, api, global, conditions */
 export declare const setApiRefGlobalConditions: (conditions: RefType<any>) => void;
+
 import { ApiInstance, ApiMethodItem, ApiData, ApiFetch, ApiErrorStorageList, ApiDataValidation } from '@dxtmisha/functional-basic';
 import { Ref } from 'vue';
-/**
- * Setup interface for API request.
- *
- * Интерфейс настроек для запроса API.
- */
+
+/** Setup interface for API request. @keywords useApiRequest setup api request configuration */
 export interface UseApiRequestSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> {
-    /**
-     * Path to the API endpoint. Can be a reactive Ref or a normal string.
-     *
-     * Путь к endpoint API. Может быть реактивным Ref или обычной строкой.
-     */
+    /** Path to the API endpoint. @keywords path endpoint api */
     path?: RefOrNormal<string | undefined>;
-    /**
-     * HTTP method used for the request (e.g., GET, POST, PUT, DELETE). Defaults to POST.
-     *
-     * HTTP метод, используемый для запроса (например, GET, POST, PUT, DELETE). По умолчанию POST.
-     */
+    /** HTTP method used for the request. @keywords method http get post */
     method?: ApiMethodItem;
-    /**
-     * Action/callback to perform after the request has successfully completed.
-     * Can return a Promise for asynchronous operations.
-     *
-     * Действие/колбэк, выполняемое после успешного завершения запроса.
-     * Может возвращать Promise для асинхронных операций.
-     */
+    /** Action callback after successful completion. @keywords action callback success */
     action?: (data: Return | undefined) => Promise<void> | void;
-    /**
-     * Transformation function that modifies the raw response data before returning it.
-     *
-     * Функция трансформации, которая преобразует исходные данные ответа перед их возвратом.
-     */
+    /** Transformation function for response data. @keywords transformation transform response data */
     transformation?: (data: T) => Return;
-    /**
-     * Function to validate the request payload contract. Used to ensure that the API
-     * request payload matches the expected structure.
-     *
-     * Функция для проверки контракта данных запроса. Используется для гарантии того,
-     * что отправляемая полезная нагрузка запроса API соответствует ожидаемой структуре.
-     */
+    /** Function to validate the request payload contract. @keywords validate request contract payload */
     validateRequestContract?: (data: Request) => ApiDataValidation & Return;
-    /**
-     * Function to validate response data contract. Used to ensure that the API
-     * response matches the expected structure. Highly recommended to use with `@effect/schema`.
-     * It should return `ApiDataValidation` containing a `status` ('success' or 'error')
-     * and the parsed data or errors.
-     *
-     * Функция для проверки контракта данных ответа. Используется для гарантии того, что ответ API соответствует
-     * ожидаемой структуре. Настоятельно рекомендуется использовать с `@effect/schema`. Должна возвращать объект
-     * `ApiDataValidation`, содержащий `status` ('success' или 'error') и распарсенные данные или ошибки.
-     */
+    /** Function to validate response data contract. @keywords validate response contract schema */
     validateResponseContract?: (data: T) => ApiDataValidation & Return;
-    /**
-     * Array of expected error contracts for the request (`ApiErrorStorageList`).
-     * Highly recommended to add if there is information about possible request errors. Allows you to predefine
-     * possible errors (by code, status, or custom validation) which will be centrally processed by the application.
-     *
-     * Массив контрактов ожидаемых ошибок для запроса (`ApiErrorStorageList`). Желательно добавлять, если есть
-     * информация о возможных ошибках запроса. Позволяет заранее описать возможные ошибки (по коду, статусу или
-     * кастомной валидации) для централизованной обработки в приложении.
-     */
+    /** Array of expected error contracts for the request. @keywords error contract list */
     errorContract?: ApiErrorStorageList;
-    /**
-     * If true, extracts the nested 'data' field from the response object instead of returning the raw envelope.
-     * Defaults to true.
-     *
-     * Если true, извлекает вложенное поле 'data' из объекта ответа вместо возврата исходного конверта.
-     * По умолчанию true.
-     */
+    /** If true, extracts nested data field. @keywords toData extract response data */
     toData?: boolean;
-    /**
-     * Additional request options (headers, query params, etc.).
-     *
-     * Дополнительные опции запроса (заголовки, параметры запроса и т.д.).
-     */
+    /** Additional request options. @keywords options request headers params */
     options?: ApiOptions;
-    /**
-     * Custom Api instance to execute the request on. Defaults to global Api singleton instance.
-     *
-     * Кастомный экземпляр класса Api для выполнения запроса. По умолчанию используется глобальный синглтон Api.
-     */
+    /** Custom Api instance. @keywords apiInstance custom api */
     apiInstance?: ApiInstance;
 }
+
+/** Execute an API request with loading states. @keywords useApiRequest request api fetch */
 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 */
     send(request?: Request): Promise<Return | undefined>;
 };
+
+import { 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
+ */
 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
+ */
 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';
+
 /**
- * Composable for reactive formatting of data lists based on specified rules for each property.
- * @param list source data list (Ref or ComputedRef)
- * @param options formatting settings for each property
+ * Reactively formats a list of data based on provided formatting options.
+ * @keywords useFormattersRef formatters list reactive
  */
 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>;
 };
+
+/** 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 data formatting.
- *
- * @remarks
- * Avoid using this reactive composable if reactive updates are not required.
- * For non-reactive formatting, use the standard `GeoIntl` class from `@dxtmisha/functional-basic`.
+ * Returns a class object for working with unit formatting and automatic conversions.
+ * @keywords useGeoUnitRef, geo, unit, formatting, conversion
  */
-export declare function useGeoIntlRef(): GeoIntlRef;
 export declare function useGeoUnitRef(): GeoUnitRef;
+
+import { ShallowRef } from 'vue';
+
+/**
+ * Creates a reactive variable to manage the hash.
+ * @keywords useHashRef hash reactive variable state url
+ * @param name value name
+ * @param defaultValue default value
+ */
 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
+ */
 export declare const useLazyItemByMarginRef: (element: RefType<HTMLElement | undefined>, rootMargin?: string) => {
+    /** Lazy item status */
     lazyItemStatus: ShallowRef<boolean, boolean>;
+    /** Tracked lazy item instance */
     readonly lazyItem: LazyItem | undefined;
 };
+
+import { Ref, 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
+ */
 export declare const useLazyRef: (options?: IntersectionObserverInit) => {
     intersectionObserver: IntersectionObserver | undefined;
+    /**
+     * Gets lazy item by element.
+     * @keywords getItem, lazy, element
+     */
     getItem(element?: HTMLElement): LazyItem | undefined;
+    /**
+     * Adds an element for lazy tracking.
+     * @keywords addLazyItem, lazy, track
+     */
     addLazyItem(element: Ref<HTMLElement | undefined>): ShallowRef<boolean, boolean>;
+    /**
+     * Removes an element from lazy tracking.
+     * @keywords removeLazyItem, lazy, remove
+     */
     removeLazyItem: (element?: HTMLElement) => void;
+    /**
+     * Disconnects lazy observer.
+     * @keywords disconnectLazy, lazy, observer
+     */
     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>;
+
+import { MetaRobots, Meta } from '@dxtmisha/functional-basic';
+import { Ref } from 'vue';
+
 /**
- * Vue composable for reactive meta tags management with automatic DOM synchronization.
- * Uses singleton pattern - all components share the same meta state.
+ * Vue composable for reactive meta tags management.
+ * @keywords use_meta meta tags management seo vue
  */
 export declare const useMeta: () => Readonly<{
     meta: Meta;
@@ -657,18 +1071,31 @@ 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 */
     getHtmlMeta: () => string;
+    /** Synchronizes reactive values with MetaStatic. @keywords sync meta */
     sync: () => void;
+    /** Updates MetaStatic values with current reactive state. @keywords update meta */
     update: () => void;
+    /** Updates MetaStatic values in SSR environment. @keywords update ssr */
     updateSsr: () => void;
+    /** Sets the page title. @keywords set title */
     setTitle: (value: string) => void;
+    /** Sets the keywords meta tag. @keywords set keywords */
     setKeywords: (value: string) => void;
+    /** Sets the description meta tag. @keywords set description */
     setDescription: (value: string) => void;
+    /** Sets the author meta tag. @keywords set author */
     setAuthor: (value: string) => void;
+    /** Sets the Open Graph / Twitter Card image URL. @keywords set image */
     setImage: (value: string) => void;
+    /** Sets the canonical URL. @keywords set canonical */
     setCanonical: (value: string) => void;
+    /** Sets the robots meta tag directive. @keywords set robots */
     setRobots: (value: MetaRobots) => void;
+    /** Sets the site name for Open Graph and Twitter Card. @keywords set site name */
     setSiteName: (value: string) => void;
+    /** Sets the suffix for the page title. @keywords set suffix */
     setSuffix: (suffix: string) => void;
 } & {
     init(): Readonly<{
@@ -681,182 +1108,217 @@ 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 */
         getHtmlMeta: () => string;
+        /** Synchronizes reactive values with MetaStatic. @keywords sync meta */
         sync: () => void;
+        /** Updates MetaStatic values with current reactive state. @keywords update meta */
         update: () => void;
+        /** Updates MetaStatic values in SSR environment. @keywords update ssr */
         updateSsr: () => void;
+        /** Sets the page title. @keywords set title */
         setTitle: (value: string) => void;
+        /** Sets the keywords meta tag. @keywords set keywords */
         setKeywords: (value: string) => void;
+        /** Sets the description meta tag. @keywords set description */
         setDescription: (value: string) => void;
+        /** Sets the author meta tag. @keywords set author */
         setAuthor: (value: string) => void;
+        /** Sets the Open Graph / Twitter Card image URL. @keywords set image */
         setImage: (value: string) => void;
+        /** Sets the canonical URL. @keywords set canonical */
         setCanonical: (value: string) => void;
+        /** Sets the robots meta tag directive. @keywords set robots */
         setRobots: (value: MetaRobots) => void;
+        /** Sets the site name for Open Graph and Twitter Card. @keywords set site name */
         setSiteName: (value: string) => void;
+        /** Sets the suffix for the page title. @keywords set suffix */
         setSuffix: (suffix: string) => void;
     }>;
+    /** Destroys execution context. @keywords destroy execute */
     destroyExecute?(): void;
 }>;
+
+import { 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
+ */
 export declare function useQueryRef<T>(name: string, defaultValue?: T | (() => T)): ShallowRef<T>;
+
+import { Ref, ComputedRef } from 'vue';
+import { NumberOrString } from '@dxtmisha/functional-basic';
+
+/**
+ * Managing a list of links for the router.
+ * @keywords useRouterList router links navigation
+ */
 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: Ref<string, string>;
+    /** Label of selected element / Метка выбранного элемента */
     label: ComputedRef<NumberOrString>;
+    /** List of elements / Список элементов */
     list: ComputedRef<ConstrBind<T>[]>;
+    /** Navigate by name / Переход по имени */
     to: (name?: string) => void;
+    /** Transition to the main element / Переход к главному элементу */
     toMain(): void;
 };
+
+import { Ref, ComputedRef } from 'vue';
+import { SearchColumns, SearchFormatList, SearchItem, SearchOptions } from '@dxtmisha/functional-basic';
+
 /**
  * Composable for handling search logic with reactive data.
- * @param list list of items to search
- * @param columns columns to search in
- * @param value reactive search string
- * @param options search options
+ * @keywords search ref reactive list columns
  */
 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 */
     isSearch: ComputedRef<boolean>;
+    /** Search string reference. @keywords search string */
     search: Ref<string, string>;
+    /** Search loading status reference. @keywords loading status */
     loading: Ref<boolean, boolean>;
+    /** Formatted search results list. @keywords list search results */
     listSearch: ComputedRef<SearchFormatList<T, K>>;
+    /** Length of search results. @keywords length count */
     length: ComputedRef<number>;
 };
+
+import { Ref } from 'vue';
+import { SearchList, SearchColumns, SearchItem } from '@dxtmisha/functional-basic';
+
 /**
- * Composable for managing search value state and handling delays.
- * @param item search list instance
- * @param value reactive search string (optional)
+ * Manages search value state and handling delays.
+ * @keywords useSearchValueRef, search, delay, debounce, loading
  */
 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 */
     searchDelay: Ref<string, string>;
+    /** Loading status during delay */
     loading: Ref<boolean, boolean>;
 };
+
+import { Ref } from 'vue';
+
+/**
+ * Creates a reactive variable for session storage.
+ * @keywords session ref storage reactive
+ */
 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
+ */
 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';
+
 /**
- * Getting the translated text by an array of keys or a string with a key.
- *
- * It returns a `ShallowRef` that automatically updates when the global language changes.
- * Use `as const` for arrays to ensure proper TypeScript key inference.
- *
- * ### Examples
- * ```typescript
- * // 1. Using the main composable
- * const translations = useTranslateRef(['home.title', 'home.description'] as const);
- *
- * // 2. Using the shorthand 't'
- * const labels = t(['button.save', 'button.cancel'] as const);
- * ```
- *
- * @param names a string or an array with keys
- * @param translateInstance a translate instance
+ * Gets translated text by key or array of keys.
+ * @keywords translate ref localization i18n
  */
 export declare function useTranslateRef<T extends (string | string[])[]>(names: T, translateInstance?: TranslateInstance): ShallowRef<TranslateList<T>>;
+
 /**
- * Shorthand for useTranslateRef.
- * Use `as const` for arrays to ensure proper TypeScript key inference.
- *
- * @param names a string or an array with keys
+ * Shorthand alias for useTranslateRef.
+ * @keywords translate t localization i18n shorthand
  */
 export declare const t: <T extends string[]>(names: T) => ShallowRef<TranslateList<T>>;
+
+```ts
+/** Initializes user interface flags. @keywords ui, flags, initialize */
 export declare const uiMakeFlags: () => void;
+```
+
 export * from '@dxtmisha/functional-basic';
+
 import { ComputedRef, DebuggerOptions } from 'vue';
+
 /**
- * Creates a computed property that can handle asynchronous getters.
- * @param getter Asynchronous function, synchronous function, or direct value to compute the result
- * @param initialState initial value of result
- * @param ignore values to be ignored
- * @param debugOptions Used for debugging reactive computations. Supported by Vue.js library
+ * Creates a computed property that handles asynchronous getters.
+ * @keywords computed async reactive vue
  */
 export declare function computedAsync<R>(getter: (() => Promise<R>) | (() => R) | R, initialState?: (() => R) | R, ignore?: R, debugOptions?: DebuggerOptions): ComputedRef<R | undefined>;
-import { ComputedGetter } from 'vue';
+
+import { ComputedGetter, ComputedRef, DebuggerOptions } from 'vue';
+
+/**
+ * Creates a language-dependent computed reactive property.
+ * @keywords computed language reactive getter
+ */
+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 */
+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';
+
+export interface FunctionalPluginOptions {
+    api?: ApiConfig;
+    translate?: TranslateConfig;
+    location?: string | (() => string);
+    metaSuffix?: string;
+    icons?: IconsConfig;
+    iconsSocial?: InputSocialIcons;
+    router?: Router;
+    errorCauses?: ErrorCenterCauseList;
+    errorHandlers?: ErrorCenterHandlerList;
+    errorCallbacks?: ErrorCenterHandlerCallback[];
+}
+
 /**
- * Provides a `computed` reactive property whose value changes based on the current language or other conditions.
- * @param getter A function that provides the main value depending on the current language or other factors.
- * @param getterNone An alternative value returned if conditions are not met or the main getter returns undefined.
- * @param conditions A condition determining when the main getter/**
- * Types of initialization for a singleton
+ * Vue plugin for initializing and configuring global functional services.
+ * @keywords plugin, dxtFunctionalPlugin, functional, vue
+ * @example
+ * import { createApp } from 'vue'
+ * import { dxtFunctionalPlugin } from '@dxtmisha/functional'
+ * const app = createApp(App)
+ * app.use(dxtFunctionalPlugin, { api: { url: 'https://api.example.com' } })
  */
+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"
 }
-/**
- * The object returned by the factory function
- */
+
 export type ExecuteUseReturn<R> = Readonly<R & {
+    /** Returns raw instance @keywords init, raw */
     init(): Readonly<R>;
+    /** Resets cached instance @keywords destroy, reset */
     destroyExecute?(): void;
 }>;
+
 /**
- * Creates a managed singleton that encapsulates initialization logic and access mode.
- *
- * It supports three initialization strategies:
- * - `global`: A single instance for the entire application.
- * - `provide`: Shared via provide/inject in the component tree (standard for Vue 3).
- * - `local`: A single instance within the closure of the returned function.
- *
- * @template R return type of the factory function
- * @template O argument types for the factory function
- * @template RI instance type with management methods
- * @param callback initialization function
- * @param type initialization strategy (defaults to provide)
- * @returns accessor function for the singleton
- *
- * @remarks
- * Use this function in the following cases:
- * - **API Services:** Always wrap API clients to ensure a single connection point and unified state.
- * - **Resource Optimization:** For functions where creating multiple instances is undesirable (e.g., heavy objects, event buses).
- * - **Shared State:** To share reactive state within a component tree using the `provide` strategy.
- * - **External SDKs:** Initializing third-party libraries (analytics, maps, charts) that should be singletons.
- *
- * @example
- * // 1. Global API singleton (useApiGet)
- * export const useUserApi = executeUseGlobal(() => {
- *   return useApiGet('/api/user');
- * });
- *
- * @example
- * // 2. Shared Reactive State
- * export const useFeatureState = executeUseProvide(() => {
- *   const items = [];
- *   const addItem = (item) => items.push(item);
- *   return { items, addItem };
- * });
- *
- * @example
- * // 3. Local Caching
- * export const useHeavyResource = executeUseLocal((config) => {
- *   return new HeavyResource(config);
- * });
- *
- * @example
- * // 4. Complex API Service (useApiManagementRef)
- * export const useUserManagement = executeUseGlobal(() => {
- *   return useApiManagementRef(
- *     { path: '/api/users' },                 // GET setup
- *     { date: (v) => new Date(v).toLocaleString() }, // Formatters
- *     { columns: ['name', 'email'] },         // Search
- *     { path: '/api/users' },                 // POST (create)
- *     { path: (o) => `/api/users/${o.id}` },  // PUT (update)
- *     { path: (o) => `/api/users/${o.id}` }   // DELETE (remove)
- *   );
- * });
- *
- * // Usage in component:
- * // const { list, loading, sendPost, sendDelete } = useUserManagement();
+ * Creates a managed singleton with initialization strategies.
+ * @keywords execute, use, singleton, factory
  */
 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.
- *
- * @remarks
- * See {@link executeUse} for more details.
- *
- * @param callback Initialization function
+ * @keywords execute, use, global, singleton
  */
 export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<R & {
     init(): Readonly<R>;
@@ -865,14 +1327,10 @@ export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<
     init(): Readonly<R>;
     destroyExecute?(): void;
 }>);
+
 /**
  * Creates a component-scoped singleton.
- *
- * @remarks
- * Best for sharing state within a component sub-tree.
- * See {@link executeUse} for more details.
- *
- * @param callback Initialization function
+ * @keywords execute, use, provide, singleton
  */
 export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
     init(): Readonly<R>;
@@ -881,14 +1339,10 @@ export declare function executeUseProvide<R, O extends any[]>(callback: (...args
     init(): Readonly<R>;
     destroyExecute?(): void;
 }>);
+
 /**
  * Creates a local singleton.
- *
- * @remarks
- * Best for internal state preservation within a closure.
- * See {@link executeUse} for more details.
- *
- * @param callback Initialization function
+ * @keywords execute, use, local, singleton
  */
 export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
     init(): Readonly<R>;
@@ -896,391 +1350,297 @@ export declare function executeUseLocal<R, O extends any[]>(callback: (...args:
 }>) | (() => Readonly<R & {
     init(): Readonly<R>;
     destroyExecute?(): void;
-}>);itialization function/ Функция инициализации
- */
-export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<R & {
-    /**
-     * Returns the raw instance without management methods/
-     * Возвращает чистый экземпляр без методов управления
-     */
-    init(): Readonly<R>;
-    /**
-     * Resets the cached instance (available for local and global)/
-     * Сбрасывает закешированный экземпляр (доступно для local и global)
-     */
-    destroyExecute?(): void;
-}>) | (() => Readonly<R & {
-    /**
-     * Returns the raw instance without management methods/
-     * Возвращает чистый экземпляр без методов управления
-     */
-    init(): Readonly<R>;
-    /**
-     * Resets the cached instance (available for local and global)/
-     * Сбрасывает закешированный экземпляр (доступно для local и global)
-     */
-    destroyExecute?(): void;
 }>);
+
 /**
- * Creates a component-scoped singleton.
- *
- * Создает компонентный синглтон.
- *
- * @remarks
- * Best for sharing state within a component sub-tree.
- * See {@link executeUse} for more details.
- *
- * Лучше всего подходит для совместного использования состояния внутри поддерева компонентов.
- * Подробнее см. {@link executeUse}.
- *
- * @param callback Initialization function/ Функция инициализации
+ * Initializes all global callbacks.
+ * @keywords execute, use, global, init
  */
-export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
-    /**
-     * Returns the raw instance without management methods/
-     * Возвращает чистый экземпляр без методов управления
-     */
-    init(): Readonly<R>;
-    /**
-     * Resets the cached instance (available for local and global)/
-     * Сбрасывает закешированный экземпляр (доступно для local и global)
-     */
-    destroyExecute?(): void;
-}>) | (() => Readonly<R & {
-    /**
-     * Returns the raw instance without management methods/
-     * Возвращает чистый экземпляр без методов управления
-     */
-    init(): Readonly<R>;
-    /**
-     * Resets the cached instance (available for local and global)/
-     * Сбрасывает закешированный экземпляр (доступно для local и global)
-     */
-    destroyExecute?(): void;
-}>);
+export declare function executeUseGlobalInit(): void;
+
 /**
- * Creates a local singleton.
- *
- * Создает локальный синглтон.
- *
- * @remarks
- * Best for internal state preservation within a closure.
- * See {@link executeUse} for more details.
- *
- * Лучше всего подходит для сохранения внутреннего состояния внутри замыкания.
- * Подробнее см. {@link executeUse}.
- *
- * @param callback Initialization function/ Функция инициализации
+ * Get injected value by name.
+ * @keywords get_inject dependency injection
  */
-export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
-    /**
-     * Returns the raw instance without management methods/
-     * Возвращает чистый экземпляр без методов управления
-     */
-    init(): Readonly<R>;
-    /**
-     * Resets the cached instance (available for local and global)/
-     * Сбрасывает закешированный экземпляр (доступно для local и global)
-     */
-    destroyExecute?(): void;
-}>) | (() => Readonly<R & {
-    /**
-     * Returns the raw instance without management methods/
-     * Возвращает чистый экземпляр без методов управления
-     */
-    init(): Readonly<R>;
-    /**
-     * Resets the cached instance (available for local and global)/
-     * Сбрасывает закешированный экземпляр (доступно для local и global)
-     */
-    destroyExecute?(): void;
-}>);
-export declare function executeUseGlobalInit(): void;
 export declare function getInject<T>(name: string): T | undefined;
+
+/** Get request options. @keywords get_options request api */
 export declare const getOptions: (options?: ApiOptions) => RefOrNormal<ApiFetch>;
+
 /**
- * Executes a function if the provided argument is a function, and unwraps the resulting Vue Ref if it is reactive.
- * If the argument is a Vue Ref or a primitive value, it unwraps or returns it directly.
- * @param data reactive reference, plain value, or a function returning them
- * @returns the resolved and unwrapped value
+ * Executes a function if provided and unwraps the resulting Vue Ref.
+ * @keywords execute, function, ref, unwrap, reactive
  */
 export declare function executeFunctionRef<T>(data: RefOrNormalOrFunction<T>): T;
+
+import { ComputedRef } from 'vue';
+import { ApiData, ApiErrorItem } from '@dxtmisha/functional-basic';
+
+/**
+ * Returns the error item for the Api ref.
+ * @keywords api error ref reactive getApiErrorRef
+ */
 export declare function getApiErrorRef<R>(data: RefType<ApiData<R> | undefined>): ComputedRef<ApiErrorItem | undefined>;
+
+import { ComputedRef } from 'vue';
+import { ItemList } from '@dxtmisha/functional-basic';
+
+/**
+ * Generates a computed reference for subcomponent bindings.
+ * @keywords get_bind_ref reactive properties computed binding
+ */
 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 */
 export declare function getRef<T>(item: RefOrNormal<T>): T;
+
+import { VNode } from 'vue';
+import { ItemList } from '@dxtmisha/functional-basic';
+
+/** Render virtual node with cached properties. @keywords render, vnode, components */
 export declare function render<T extends ItemList>(name: string | any, props?: T, children?: RawChildren | RawSlots, index?: string): VNode;
+
+import { Ref } from 'vue';
+
+/**
+ * Changes the value of a reactive reference.
+ * @keywords set ref value 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
+ */
 export declare function toRefItem<T>(item: RefOrNormal<T>): Ref<T>;
+
+/**
+ * Generates component binding properties.
+ * @keywords getBind bind properties component attributes
+ */
 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 { ItemList } from '@dxtmisha/functional-basic';
+
 /**
- * Returns or generates a new element.
- *
- * Возвращает или генерирует новый элемент.
- * @param name name of the component/ названия компонента
- * @param props property of the component/ свойство компонента
- * @param index the name of the key/ названия ключа
+ * Returns or generates a render index string.
+ * @keywords render, index, key, generator
  */
 export declare function getIndexForRender<T extends ItemList>(name: string | any, props?: T, index?: string): string | undefined;
-import { ItemList } from '@dxtmisha/functional-basic';
+
 /**
  * Merges two objects with properties, taking into account their classes and styles
- *
- * Объединяет два объекта со свойствами с учётом классов и стилей в них
- * @param extra additional property/ дополнительное свойство
- * @param value input value/ входное значение
+ * @keywords toBind merge objects class style bind
  */
 export declare function toBind<R extends ItemList = ItemList>(extra: ItemList, value: ItemList): ConstrBind<R>;
-import { ItemList } from '@dxtmisha/functional-basic';
-/**
- * Merges multiple objects with properties, taking into account their classes and styles
- *
- * Объединяет несколько объектов со свойствами с учётом классов и стилей в них
- * @param values list of input values/ список входных значений
- */
+
+/** Merges multiple objects into a single bound object with combined classes and styles. @keywords toBinds merge bind styles classes */
 export declare function toBinds<R extends ItemList = ItemList>(...values: (ItemList | undefined)[]): ConstrBind<R>;
-import { ApiData, ApiDataValidation, ApiDefaultValue, ApiErrorStorageList, ApiFetch, ApiMethodItem, SearchColumns, SearchItem, SearchOptions } from '@dxtmisha/functional-basic';
-import { Ref } from 'vue';
-/** Options for api requests/ Опции для запросов api */
+
+
+
 export type ApiOptions = ApiMethodItem | RefOrNormal<ApiFetch>;
-/**
- * Base type for API management values, either a single value or an array.
- *
- * Базовый тип для значений управления API: одиночное значение или массив.
- */
 export type ApiManagementValue = ApiDefaultValue | ApiDefaultValue[];
-/**
- * Configuration for the main GET request in API management.
- */
 export type ApiManagementGet<Return extends ApiManagementValue, Type extends ApiManagementValue = Return> = {
-    /** API endpoint path */
     path?: RefOrNormal<string | undefined>;
-    /** Additional request options */
     options?: ApiOptions;
-    /** Enable reactive updates when path or options change */
     reactivity?: boolean;
-    /** Condition to trigger the request */
     conditions?: RefType<boolean>;
-    /** Custom transformation for the fetched data */
     transformation?: (data: Type, isResponseContractValid?: ApiDataValidation) => ApiData<Return>;
-    /** Function to validate response data contract */
     validateResponseContract?: (data: Type) => ApiDataValidation;
-    /** Storage of response error contracts */
     errorContract?: ApiErrorStorageList;
-    /** Validation function or class constructor for data */
     typeData?: ((data: Return) => boolean) | any;
-    /** Whether to clear data when the component is unmounted */
     unmounted?: boolean;
-    /** Function to provide skeleton data during loading */
     skeleton?: () => Return;
 };
-/**
- * Configuration for client-side search across API data.
- */
 export type ApiManagementSearch<T extends SearchItem, K extends SearchColumns<T>> = {
-    /** List of columns to search through */
     columns: K;
-    /** Reactive search query */
     value?: Ref<string>;
-    /** Additional search algorithm options */
     options?: SearchOptions;
 };
-/**
- * Configuration for mutation requests (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>;
-    /** Action to perform after a successful request */
     action?: (data: Return | undefined) => Promise<void> | void;
-    /** Transformation 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;
-    /** Whether to wrap the payload in a 'data' property */
     toData?: boolean;
-    /** Additional mutation request options */
     options?: ApiOptions;
 };
-import { Ref, PropType, ComputedRef } from 'vue';
-import { Undefined } from '@dxtmisha/functional-basic';
-/** Generic record type for constructor items */
+
 export type ConstrItem = Record<string, any>;
-/** Constructor value wrapper with optional value property */
 export type ConstrValue<T = any> = {
-    /** Optional value of type T */
     value?: T;
 };
-/** Generic record type for constructor components */
 export type ConstrComponent = Record<string, any>;
-/** Constructor component modification type with reactive or normal values */
 export type ConstrComponentMod<P extends ConstrItem> = ConstrItem | {
     [K in keyof P]?: RefOrNormal<P[K]>;
 };
 export type ConstrExpose<E extends Element, EXPOSE extends ConstrItem> = EXPOSE & {
     elementHtml?: ComputedRef<E | undefined>;
 };
-/** Utility type to convert union types to intersection types */
 export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-/** Extract emit item type from constructor item */
 export type ConstrEmitItem<T extends ConstrItem> = T[keyof T];
-/** Constructor emit type with proper event handler signatures */
 export type ConstrEmit<T extends ConstrItem = ConstrItem> = UnionToIntersection<ConstrEmitItem<{
     [K in keyof T]: (evt: K, ...args: T[K]) => void;
 }>>;
-/** Object type for CSS class names with boolean values */
 export type ConstrClassObject = Record<string, boolean | undefined>;
-/** Constructor class type supporting strings, arrays, and objects */
 export type ConstrClass = string | (string | ConstrClass | Undefined)[] | ConstrClassObject;
-/** Record type for mapping class names to class definitions */
 export type ConstrClassList = Record<string, ConstrClass>;
-/** Constructor classes with required main class and additional class list */
 export type ConstrClasses = {
     main: ConstrClass;
 } & ConstrClassList;
-/** Constructor style item type for individual style properties */
 export type ConstrStylesItem = string | null;
-/** Constructor styles type supporting objects and arrays of style definitions */
 export type ConstrStyles = Record<string, ConstrStylesItem> | ConstrStyles[];
-/** Constructor options interface for component configuration */
+/** Constructor options for component configuration @keywords options setup component */
 export type ConstrOptions<COMP extends ConstrComponent, EMITS extends ConstrItem, P extends ConstrItem> = {
-    /** Optional components configuration */
     components?: COMP;
-    /** Optional component modifications */
     compMod?: ConstrComponentMod<P>;
-    /** Optional emit handlers */
     emits?: ConstrEmit<EMITS>;
-    /** Optional reactive classes */
     classes?: RefType<ConstrClasses>;
-    /** Optional reactive styles */
     styles?: RefType<ConstrStyles>;
 };
-/** Constructor setup interface for component initialization */
+/** Constructor setup structure for component initialization @keywords setup initialization */
 export type ConstrSetup<E extends Element, CLASSES extends ConstrClasses, SETUP extends ConstrItem> = {
-    /** Component name */
     name: string;
-    /** Reactive element reference */
     element: Ref<E | undefined>;
-    /** Reactive classes */
     classes: RefType<CLASSES>;
-    /** Reactive styles */
     styles: RefType<ConstrStyles>;
 } & SETUP;
-/** Constructor registration configuration */
 export type ConstrRegistration = {
-    /** Optional flag for registration */
     flag?: boolean;
-    /** Optional translation map */
     translate?: Record<string, string>;
 };
-/** Constructor bind type for component binding with class and style support */
+/** Constructor bind type with class and style support @keywords bind attributes */
 export type ConstrBind<T> = T & Record<string, any> & {
-    /** Optional key */
     key?: string;
-    /** Optional CSS classes */
     class?: ConstrClass;
-    /** Optional styles */
     style?: ConstrStyles;
 };
-/** Constructor prop item options for Vue prop definitions */
 export type ConstrPropItemOptions<T = any> = {
-    /** Vue prop type */
     type?: PropType<T>;
-    /** Required flag */
     required?: boolean;
-    /** Default value */
     default?: any;
-    /** Custom validator function */
     validator?(value: any, props: any): boolean;
 };
-/** Constructor prop item type with options or direct PropType */
 export type ConstrPropItem<T = any> = ConstrPropItemOptions<T> | PropType<T>;
-/** Constructor props type for component prop definitions */
 export type ConstrProps<P = Record<string, any>> = {
     [K in keyof P]: ConstrPropItem<P[K]>;
 };
-/** Props for link handling */
+/** Hyperlink props definition @keywords href link properties */
 export type ConstrHrefProps = {
-    /** Hyperlink reference */
     href?: string;
 };
-/** Type of list item */
+
+import { NumberOrString, NumberOrStringOrBoolean } from '@dxtmisha/functional-basic';
+
+/** Type of list item @keywords list, type, item */
 export type ListType = 'item' | 'space' | 'line' | 'subtitle' | 'html' | 'menu' | 'menu-group' | 'group';
-/** Basic data structure for list item */
+
+/** Basic data structure for list item @keywords list, data, basic */
 export type ListDataBasic = {
-    /** Optional display label */
     label?: NumberOrString;
-    /** Any value associated with the item */
     value?: any;
-    /** Search text for filtering */
     search?: string;
 };
-/** Extended list item with type and index */
+
+/** Extended list item with type and index @keywords list, item, extended */
 export type ListDataItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item & {
-    /** Parent item identifier */
     parent?: string;
-    /** Type of list item */
     type: ListType;
-    /** Unique item identifier */
     index: string;
-    /** Whether the item is disabled */
     disabled?: boolean;
 }>;
-/** Array of list data items */
+
+/** 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 */
+
+/** 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 */
+
+/** Extended list item with additional state properties @keywords list, item, full, state */
 export type ListDataFullItem<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item> & {
-    /** Whether the item has focus */
     focus: boolean;
-    /** Highlighted text portion */
     highlight?: string;
-    /** Whether the item is selected */
     selected: boolean;
-    /** Whether the item is disabled */
     disabled?: boolean;
 };
-/** Array of extended list items with state */
+
+/** 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 */
+
+/** Input item for list creation @keywords list, input, item */
 export type ListListInputItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item>;
-/** Various input formats for list creation */
+
+/** Various input formats for list creation @keywords list, input, formats */
 export type ListListInput<Item extends ListDataBasic = ListDataBasic> = ListListInputItem<Item>[] | string[] | Record<string, ListListInputItem<Item>> | Record<string, string>;
-/** Single selected item identifier */
+
+/** Single selected item identifier @keywords list, selected, item */
 export type ListSelectedItem = NumberOrStringOrBoolean;
-/** Single or multiple selected items */
+
+/** Single or multiple selected items @keywords list, selected, list */
 export type ListSelectedList = ListSelectedItem | ListSelectedItem[];
-/** Name of selected list item */
+
+/** Name of selected list item @keywords list, name */
 export type ListName = string | number | undefined;
-/** Array of list item names */
+
+/** Array of list item names @keywords list, names, array */
 export type ListNames = ListName[];
-/** Union type for Vue reactive references (computed or ref) */
+
+import { ComputedRef, Ref, VNode, VNodeArrayChildren } from 'vue';
+
+/**
+ * Union type for Vue reactive references (computed or ref)
+ * @keywords ref type computed reactive
+ */
 export type RefType<T> = ComputedRef<T> | Ref<T>;
-/** Union type for Vue reactive references that can be undefined */
+
+/**
+ * Union type for Vue reactive references that can be undefined
+ * @keywords ref undefined computed reactive
+ */
 export type RefUndefined<T> = RefType<T | undefined>;
-/** Union type that can be either a Vue reactive reference or a normal value */
+
+/**
+ * Union type that can be either a Vue reactive reference or a normal value
+ * @keywords ref normal value reactive
+ */
 export type RefOrNormal<T> = RefType<T> | T;
-/** Union type that can be either a Vue reactive reference or a normal value or a function that returns a Vue reactive reference or a normal value */
+
+/**
+ * Union type that can be a Vue reactive reference, normal value, or function returning them
+ * @keywords ref normal function reactive
+ */
 export type RefOrNormalOrFunction<T> = RefOrNormal<T> | (() => RefOrNormal<T>);
-/** Union type for Vue raw children content (strings, numbers, booleans, VNodes, arrays, functions) */
+
+/**
+ * Union type for Vue raw children content
+ * @keywords raw children vnode array
+ */
 export type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
-/** Type for Vue raw slots with optional stability flag */
+
+/**
+ * Type for Vue raw slots with optional stability flag
+ * @keywords raw slots stable vue
+ */
 export type RawSlots = {
-    /** Slot name mapping to unknown content */
     [name: string]: unknown;
-    /** Optional stability flag for performance optimization */
     $stable?: boolean;
 };
-/** Search list data */
+
+import { SearchColumns, SearchItem, SearchListValue } from '@dxtmisha/functional-basic';
+/** Search list value reference @keywords search list value ref */
 export type SearchListValueRef<T extends SearchItem> = RefOrNormal<SearchListValue<T>>;
-/** Search list input */
+/** Search list input configuration @keywords search list input */
 export type SearchListInput<T extends SearchItem> = SearchListValueRef<T> | (() => SearchListValueRef<T>);
-/** Search columns ref */
+/** Search columns reference @keywords search columns ref */
 export type SearchColumnsRef<T extends SearchItem, K extends SearchColumns<T>> = RefOrNormal<K>;
-/** Search columns input */
+/** Search columns input configuration @keywords search columns input */
 export type SearchColumnsInput<T extends SearchItem, K extends SearchColumns<T>> = SearchColumnsRef<T, K> | (() => SearchColumnsRef<T, K>);