@dxtmisha/functional 1.10.3 → 1.11.0

package/ai-types.txt

@@ -0,0 +1,812 @@
+1) All these methods are in the @dxtmisha/functional library.
+2) Everything that is exported can be used.
+3) Use what is in this library if it exists; do not use other libraries if there is an analogue here. Do not create new ones if an analogue already exists here.
+
+The following is the content of "exports" from package.json:
+{
+  ".": {
+    "import": "./dist/library.js",
+    "types": "./dist/library.d.ts"
+  },
+  "./flags": {
+    "import": "./dist/flags.js",
+    "types": "./dist/flags.d.ts"
+  },
+  "./types/*": "./dist/*"
+}
+
+// File: library.d.ts
+
+/** Config for main API GET request. */
+export declare type ApiManagementGet<Return extends ApiManagementValue, Type extends ApiManagementValue = Return> = {
+    /** API endpoint path. */
+    path?: RefOrNormal<string | undefined>;
+    /** Request options. */
+    options?: ApiOptions;
+    /** Enable reactive updates on path/options change. */
+    reactivity?: boolean;
+    /** Trigger condition. */
+    conditions?: RefType<boolean>;
+    /** Custom data transformation. */
+    transformation?: (data: Type, isResponseContractValid?: ApiDataValidation) => ApiData<Return>;
+    /** Response contract validation. */
+    validateResponseContract?: (data: Type) => ApiDataValidation;
+    /** Data type validation or constructor. */
+    typeData?: ((data: Return) => boolean) | any;
+    /** Clear data on unmount. */
+    unmounted?: boolean;
+    /** Loading skeleton data. */
+    skeleton?: () => Return;
+};
+
+/** Config for POST, PUT, DELETE requests. */
+export declare type ApiManagementRequest<T, Return extends ApiData<T> = ApiData<T>> = {
+    /** API endpoint path. */
+    path?: RefOrNormal<string | undefined>;
+    /** Success callback. */
+    action?: (data: Return | undefined) => Promise<void> | void;
+    /** Pre-send transformation. */
+    transformation?: (data: T) => Return;
+    /** Wrap payload in 'data' property. */
+    toData?: boolean;
+    /** Request options. */
+    options?: ApiOptions;
+};
+
+/** Config for client-side search. */
+export declare type ApiManagementSearch<T extends SearchItem, K extends SearchColumns<T>> = {
+    /** Searchable columns. */
+    columns: K;
+    /** Reactive search query. */
+    value?: Ref<string>;
+    /** Search algorithm options. */
+    options?: SearchOptions;
+};
+
+/** API value or array of values. */
+export declare type ApiManagementValue = ApiDefaultValue | ApiDefaultValue[];
+
+/** API request options. */
+export declare type ApiOptions = ApiMethodItem | RefOrNormal<ApiFetch>;
+
+declare type BroadcastValueItem<T> = T | string | undefined;
+
+/** Creates computed property for async getters. */
+export declare function computedAsync<R>(getter: (() => Promise<R>) | (() => R) | R, ignore?: R, debugOptions?: DebuggerOptions): ComputedRef<R | undefined>;
+
+/** Creates computed property that reacts to language changes. */
+export declare function computedByLanguage<T, R extends (T | undefined) = T | undefined>(getter: ComputedGetter<R>, getterNone?: R | (() => R), conditions?: () => boolean, debugOptions?: DebuggerOptions): ComputedRef<R>;
+
+/** Creates on-demand cached computed property. Watcher stays active for app life. */
+export declare function computedEternity<T>(getter: () => Promise<T> | T): Ref<T, T>;
+
+/** Component binding with class/style support. */
+export declare type ConstrBind<T> = T & Record<string, any> & {
+    key?: string;
+    class?: ConstrClass;
+    style?: ConstrStyles;
+};
+
+/** Constructor class type (string, array, or object). */
+export declare type ConstrClass = string | (string | ConstrClass | Undefined)[] | ConstrClassObject;
+
+/** Main class and additional class list. */
+export declare type ConstrClasses = {
+    main: ConstrClass;
+} & ConstrClassList;
+
+/** Record mapping class names. */
+export declare type ConstrClassList = Record<string, ConstrClass>;
+
+/** CSS class object (boolean values). */
+export declare type ConstrClassObject = Record<string, boolean | undefined>;
+
+/** Constructor component record. */
+export declare type ConstrComponent = Record<string, any>;
+
+/** Component modification with reactive values. */
+export declare type ConstrComponentMod<P extends ConstrItem> = ConstrItem | {
+    [K in keyof P]?: RefOrNormal<P[K]>;
+};
+
+/** Constructor emit signatures. */
+export declare type ConstrEmit<T extends ConstrItem = ConstrItem> = UnionToIntersection<ConstrEmitItem<{
+    [K in keyof T]: (evt: K, ...args: T[K]) => void;
+}>>;
+
+/** Extract emit item type. */
+export declare type ConstrEmitItem<T extends ConstrItem> = T[keyof T];
+
+export declare type ConstrExpose<E extends Element, EXPOSE extends ConstrItem> = EXPOSE & {
+    elementHtml?: ComputedRef<E | undefined>;
+};
+
+/** Props for links. */
+export declare type ConstrHrefProps = {
+    href?: string;
+};
+
+/** Constructor item record. */
+export declare type ConstrItem = Record<string, any>;
+
+/** Constructor configuration options. */
+export declare type ConstrOptions<COMP extends ConstrComponent, EMITS extends ConstrItem, P extends ConstrItem> = {
+    components?: COMP;
+    compMod?: ConstrComponentMod<P>;
+    emits?: ConstrEmit<EMITS>;
+    classes?: RefType<ConstrClasses>;
+    styles?: RefType<ConstrStyles>;
+};
+
+/** Constructor prop item (options or PropType). */
+export declare type ConstrPropItem<T = any> = ConstrPropItemOptions<T> | PropType<T>;
+
+/** Vue prop definition options. */
+export declare type ConstrPropItemOptions<T = any> = {
+    type?: PropType<T>;
+    required?: boolean;
+    default?: any;
+    validator?(value: any, props: any): boolean;
+};
+
+/** Component prop definitions. */
+export declare type ConstrProps<P = Record<string, any>> = {
+    [K in keyof P]: ConstrPropItem<P[K]>;
+};
+
+/** Constructor registration config. */
+export declare type ConstrRegistration = {
+    flag?: boolean;
+    translate?: Record<string, string>;
+};
+
+/** Component setup interface. */
+export declare type ConstrSetup<E extends Element, CLASSES extends ConstrClasses, SETUP extends ConstrItem> = {
+    name: string;
+    element: Ref<E | undefined>;
+    classes: RefType<CLASSES>;
+    styles: RefType<ConstrStyles>;
+} & SETUP;
+
+/** Style definitions (object or array). */
+export declare type ConstrStyles = Record<string, ConstrStylesItem> | ConstrStyles[];
+
+/** Individual style property. */
+export declare type ConstrStylesItem = string | null;
+
+/** Value wrapper. */
+export declare type ConstrValue<T = any> = {
+    value?: T;
+};
+
+/** Class for date processing. */
+export declare class DatetimeRef {
+    constructor(date: RefOrNormal<NumberOrStringOrDate>, type?: RefOrNormal<GeoDate>, code?: RefOrNormal<string>);
+    /** Get base date data. */
+    getItem(): Ref<NumberOrStringOrDate>;
+    /** Get Date object. */
+    getDate(): Ref<Date>;
+    /** Get base Datetime class instance. */
+    getDatetime(): Datetime;
+    /** Get hour format. */
+    getHoursType(): ComputedRef<GeoHours>;
+    /** Get first day of week code. */
+    getFirstDayCode(): ComputedRef<GeoFirstDay>;
+    /** Get year. */
+    getYear(): ComputedRef<number>;
+    /** Get zero-based month. */
+    getMonth(): ComputedRef<number>;
+    /** Get day of month. */
+    getDay(): ComputedRef<number>;
+    /** Get hour. */
+    getHour(): ComputedRef<number>;
+    /** Get minutes. */
+    getMinute(): ComputedRef<number>;
+    /** Get seconds. */
+    getSecond(): ComputedRef<number>;
+    /** Get last day of week. */
+    getMaxDay(): ComputedRef<number>;
+    /** Get language-sensitive formatting. */
+    locale(type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions): ComputedRef<string>;
+    /** Standard data output. */
+    standard(timeZone?: boolean): ComputedRef<string>;
+}
+
+/** Abstract base for constructor logic. */
+export declare abstract class DesignAbstract<T extends Record<string, any>, C extends Record<string, any>> {
+    constructor(props: T, callback?: ((event: C) => void) | undefined, changed?: string[]);
+    /** Executes callback. */
+    make(compelled?: boolean): this;
+    /** Executes callback. */
+    makeCallback(compelled?: boolean): void;
+}
+
+/** Abstract base for async constructor logic. */
+export declare abstract class DesignAsyncAbstract<T extends Record<string, any>, C extends Record<string, any>> extends DesignAbstract<T, C> {
+    make(compelled?: boolean): this;
+    makeCallback(compelled?: boolean): Promise<void>;
+}
+
+/** Checks for edited values. */
+export declare class DesignChanged<T extends Record<string, any>> {
+    constructor(props: T, watch?: string[]);
+    /** Check if specific property updated. */
+    is(name: string | string[]): boolean;
+    /** Check if any data changed. */
+    isChanged(): boolean;
+    /** Update all cached values. */
+    update(): void;
+}
+
+export declare class DesignComp<COMP extends ConstrComponent, P extends ConstrItem> extends DesignComponents<COMP, P> {
+}
+
+/** Manager for connected components. */
+export declare class DesignComponents<COMP extends ConstrComponent, P extends ConstrItem> {
+    constructor(components?: COMP, modification?: ConstrComponentMod<P> | undefined);
+    /** Check component presence. */
+    is<K extends keyof COMP>(name: K): name is K;
+    /** Get component object. */
+    get<K extends keyof COMP>(name: K): COMP[K];
+    /** Get modified input data. */
+    getModification<K extends keyof P>(index?: K & string | string, props?: P[K] | Record<string, any>): Record<string, any> | undefined;
+    /** Render component in 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[];
+    /** Render single 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;
+    /** Add rendered component to array. */
+    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;
+}
+
+/** Base class for functional component assembly. */
+export declare abstract class DesignConstructorAbstract<E extends Element, COMP extends ConstrComponent, EMITS extends ConstrItem, EXPOSE extends ConstrItem, SLOTS extends ConstrItem, CLASSES extends ConstrClasses, P extends ConstrItem> {
+    protected constructor(name: string, props: Readonly<P>, options?: ConstrOptions<COMP, EMITS, P> | undefined);
+    protected init(): this;
+    /** Get class name. */
+    getName(): string;
+    /** Get design name. */
+    getDesign(): string;
+    /** Get sub-class name. */
+    getSubClass(name: string | string[]): string;
+    /** Get status-specific class name. */
+    getStatusClass(name: string | string[]): string;
+    /** Get style property name. */
+    getStyle(name: string | string[]): string;
+    /** Get extra parameters. */
+    getAttrs(): ConstrItem;
+    /** Expose public variables. */
+    expose(): ConstrExpose<E, EXPOSE>;
+    /** Vue setup render method. */
+    render(): () => VNode | (VNode | any)[] | undefined;
+}
+
+/**
+ * Vue plugin for initializing global services.
+ * @example
+ * ```typescript
+ * app.use(dxtFunctionalPlugin, { api: { url: '...' }, router })
+ * ```
+ */
+export declare const dxtFunctionalPlugin: Plugin_2;
+
+/** Global effect scope utility. */
+export declare class EffectScopeGlobal {
+    /** Run function in global scope. */
+    static run<T>(fn: () => T): T | undefined;
+}
+
+/** Reactive event handling class. */
+export declare class EventRef<E extends ElementOrWindow, O extends Event, D extends Record<string, any> = Record<string, any>> extends EventItem<E, O, D> {
+    constructor(elementSelector?: RefOrNormal<ElementOrString<E> | undefined>, elementSelectorControl?: RefOrNormal<ElementOrString<HTMLElement>>, type?: string | string[], listener?: EventListenerDetail<O, D>, options?: EventOptions, detail?: D);
+}
+
+/**
+ * Creates a managed singleton (global, provide, or local).
+ * @remarks
+ * Use for API services, resource optimization, shared state, or SDK initialization.
+ * @example
+ * export const useUserApi = executeUseGlobal(() => useApiGet('/api/user'));
+ */
+export declare function executeUse<R, O extends any[], RI extends ExecuteUseReturn<R> = ExecuteUseReturn<R>>(callback: (...args: O) => R, type?: ExecuteUseType): ((...args: O) => RI) | (() => RI);
+
+/** Creates a global singleton. */
+export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<R & {
+    init(): Readonly<R>;
+    destroyExecute?(): void;
+}>);
+
+/** Initializes global callbacks. */
+export declare function executeUseGlobalInit(): void;
+
+/** Creates a local singleton. */
+export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
+    init(): Readonly<R>;
+    destroyExecute?(): void;
+}>);
+
+/** Creates a component-scoped singleton. */
+export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
+    init(): Readonly<R>;
+    destroyExecute?(): void;
+}>);
+
+/** Managed singleton return type. */
+export declare type ExecuteUseReturn<R> = Readonly<R & {
+    init(): Readonly<R>;
+    destroyExecute?(): void;
+}>;
+
+/** Singleton initialization strategies. */
+export declare enum ExecuteUseType {
+    global = "global",
+    provide = "provide",
+    local = "local"
+}
+
+/** Options for the functional plugin. */
+export declare interface FunctionalPluginOptions {
+    api?: ApiConfig;
+    translate?: TranslateConfig;
+    metaSuffix?: string;
+    icons?: IconsConfig;
+    router?: Router;
+    errorCauses?: ErrorCenterCauseList;
+}
+
+/** Reactive Flag management. */
+export declare class GeoFlagRef {
+    constructor(code?: RefOrNormal<string>);
+    /** Get reactive country code. */
+    getCode(): Ref<string>;
+    /** Get country/flag info. */
+    get(code?: string): ComputedRef<GeoFlagItem | undefined>;
+    /** Get flag link. */
+    getFlag(code?: string): ComputedRef<string | undefined>;
+    /** Get list by country codes. */
+    getList(codes?: string[]): ComputedRef<GeoFlagItem[]>;
+    /** Get list in national language. */
+    getNational(codes?: string[]): ComputedRef<GeoFlagNational[]>;
+}
+
+/** Reactive formatting for numbers and dates. */
+export declare class GeoIntlRef {
+    constructor(code?: RefOrNormal<string>);
+    /** Display names for languages/regions. */
+    display(value?: RefOrNormal<string>, typeOptions?: Intl.DisplayNamesOptions['type'] | Intl.DisplayNamesOptions): ComputedRef<string>;
+    /** Language display name. */
+    languageName(value?: RefOrNormal<string>, style?: Intl.RelativeTimeFormatStyle): ComputedRef<string>;
+    /** Region display name. */
+    countryName(value?: RefOrNormal<string>, style?: Intl.RelativeTimeFormatStyle): ComputedRef<string>;
+    /** Number formatting. */
+    number(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
+    /** Decimal point symbol. */
+    decimal(): ComputedRef<string>;
+    /** Currency formatting. */
+    currency(value: RefOrNormal<NumberOrString>, currencyOptions?: RefOrNormal<string | Intl.NumberFormatOptions>, numberOnly?: boolean): ComputedRef<string>;
+    /** Currency symbol or code. */
+    currencySymbol(currency: RefOrNormal<string>, currencyDisplay?: keyof Intl.NumberFormatOptionsCurrencyDisplayRegistry): ComputedRef<string>;
+    /** Unit formatting. */
+    unit(value: RefOrNormal<NumberOrString>, unitOptions?: string | Intl.NumberFormatOptions): ComputedRef<string>;
+    /** Formatted file size. */
+    sizeFile(value: RefOrNormal<NumberOrString>, unitOptions?: 'byte' | 'kilobyte' | 'megabyte' | 'gigabyte' | 'terabyte' | 'petabyte' | Intl.NumberFormatOptions): ComputedRef<string>;
+    /** Percentage formatting. */
+    percent(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
+    /** Percentage formatting (unit). */
+    percentBy100(value: RefOrNormal<NumberOrString>, options?: Intl.NumberFormatOptions): ComputedRef<string>;
+    /** Plural rule formatting. */
+    plural(value: RefOrNormal<NumberOrString>, words: string, options?: Intl.PluralRulesOptions, optionsNumber?: Intl.NumberFormatOptions): ComputedRef<string>;
+    /** Date/time formatting. */
+    date(value: RefOrNormal<NumberOrStringOrDate>, type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions, hour24?: boolean): ComputedRef<string>;
+    /** Relative time formatting. */
+    relative(value: RefOrNormal<NumberOrStringOrDate>, styleOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions, todayValue?: Date): ComputedRef<string>;
+    /** Relative time formatting with fallback limit. */
+    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>;
+    /** Relative time by specific unit. */
+    relativeByValue(value: RefOrNormal<NumberOrString>, unit: Intl.RelativeTimeFormatUnit, styleOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions): ComputedRef<string>;
+    /** Month name. */
+    month(value?: RefOrNormal<NumberOrStringOrDate>, style?: Intl.DateTimeFormatOptions['month']): ComputedRef<string>;
+    /** List of all months. */
+    months(style?: Intl.DateTimeFormatOptions['month']): ComputedRef<ItemValue<number | undefined>[]>;
+    /** Weekday name. */
+    weekday(value?: RefOrNormal<NumberOrStringOrDate>, style?: Intl.DateTimeFormatOptions['weekday']): ComputedRef<string>;
+    /** List of all weekdays. */
+    weekdays(style?: Intl.DateTimeFormatOptions['weekday']): ComputedRef<ItemValue<number | undefined>[]>;
+    /** Time formatting. */
+    time(value: RefOrNormal<NumberOrStringOrDate>): ComputedRef<string>;
+    /** Locale-aware array sorting. */
+    sort<T>(data: RefOrNormal<T[]>, compareFn?: (a: T, b: T) => [string, string]): ComputedRef<T[]>;
+}
+
+/** Static reactive geographic data access. */
+export declare class GeoRef {
+    /** Get full geo info. */
+    static get(): Ref<GeoItemFull>;
+    /** Get country code. */
+    static getCountry(): ComputedRef<string>;
+    /** Get language code. */
+    static getLanguage(): ComputedRef<string>;
+    /** Get standard locale string. */
+    static getStandard(): ComputedRef<string>;
+    /** Get first day of week. */
+    static getFirstDay(): ComputedRef<string>;
+    /** Set locale by code. */
+    static set(code: string): void;
+}
+
+/** Generates properties for subcomponents. */
+export declare function getBind<T, R extends ItemList>(value: T | R | undefined | null, nameExtra?: ItemList | string, name?: string, except?: boolean): ConstrBind<R>;
+
+/** Generates reactive properties for subcomponents. */
+export declare function getBindRef<T, R extends ItemList>(value: RefOrNormal<T | R> | undefined, nameExtra?: RefOrNormal<ItemList> | string, name?: string): ComputedRef<R>;
+
+/** Get class name from props. */
+export declare function getClassName<T extends ItemList>(props?: T): string | undefined;
+
+/** Get or generate element index for rendering. */
+export declare function getIndexForRender<T extends ItemList>(name: string | any, props?: T, index?: string): string | undefined;
+
+/** Get API request options. */
+export declare const getOptions: (options?: ApiOptions) => RefOrNormal<ApiFetch>;
+
+/** Unwrap ref or return value. */
+export declare function getRef<T>(item: RefOrNormal<T>): T;
+
+export declare type LazyItem = {
+    status: ShallowRef<boolean>;
+    ratio: ShallowRef<number>;
+    entry: ShallowRef<IntersectionObserverEntry | undefined>;
+    stopWatch: () => void;
+};
+
+export declare type LazyItemByMargin = {
+    rootMargin: string;
+    item: any;
+};
+
+export declare type LazyList = Record<string, LazyItem>;
+
+/** List item base structure. */
+export declare type ListDataBasic = {
+    label?: NumberOrString;
+    value?: any;
+    search?: string;
+};
+
+/** List items with state. */
+export declare type ListDataFull<Item extends ListDataBasic = ListDataBasic> = ListDataFullItem<Item>[];
+
+/** List item with focus/selection state. */
+export declare type ListDataFullItem<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item> & {
+    focus: boolean;
+    highlight?: string;
+    selected: boolean;
+    disabled?: boolean;
+};
+
+/** List item with metadata. */
+export declare type ListDataItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item & {
+    parent?: string;
+    type: ListType;
+    index: string;
+}>;
+
+/** List data manager. */
+export declare class ListDataRef {
+    constructor(list: RefOrNormal<ListListInput | undefined>, focus?: RefType<ListSelectedItem | undefined> | undefined, highlight?: RefType<string | undefined> | undefined, highlightLengthStart?: RefType<number | undefined> | undefined, filterMode?: RefType<boolean | undefined> | undefined, selected?: RefType<ListSelectedList | undefined> | undefined, keyValue?: RefType<string | undefined> | undefined, keyLabel?: RefType<string | undefined> | undefined, lite?: RefType<number | undefined> | undefined, min?: RefOrNormal<number | string | undefined>, max?: RefOrNormal<number | string | undefined>, parent?: string | undefined);
+    readonly data: ComputedRef<ListList>;
+    readonly liteData: ComputedRef<ListList>;
+    readonly fullData: ComputedRef<ListDataFull>;
+    readonly map: ComputedRef<ListList>;
+    readonly mapItems: ComputedRef<ListList>;
+    readonly items: ComputedRef<ListList>;
+    readonly highlightFirstItem: ComputedRef<number>;
+    readonly isSelected: ComputedRef<boolean>;
+    readonly isSelectedMin: ComputedRef<boolean>;
+    readonly isSelectedMax: ComputedRef<boolean>;
+    readonly selectedList: ComputedRef<ListList>;
+    readonly selectedListInGroup: ComputedRef<ListList>;
+    readonly selectedNames: ComputedRef<ListNames>;
+    readonly selectedValues: ComputedRef<any[]>;
+    isLite(): boolean;
+    isFocus(): boolean;
+    isHighlight(): boolean;
+    isHighlightActive(): boolean;
+    getLength(): number;
+    getLengthByMap(): number;
+    getLengthByItems(): number;
+    getFocus(): ListSelectedItem | undefined;
+    getHighlight(): string | undefined;
+    getHighlightLengthStart(): number;
+    getSelected(): ListSelectedList | undefined;
+    getSelectedByStep(step: number): ListSelectedItem | undefined;
+    getSelectedNext(): ListSelectedItem | undefined;
+    getSelectedPrev(): ListSelectedItem | undefined;
+    getItemByStep(item: ListDataItem, step: number): ListDataItem | undefined;
+    getItemNext(item: ListDataItem): ListDataItem | undefined;
+    getItemPrev(item: ListDataItem): ListDataItem | undefined;
+    getIndexByStep(index: string, step: number): ListDataItem | undefined;
+    getIndexNext(index: string): ListDataItem | undefined;
+    getIndexPrev(index: string): ListDataItem | undefined;
+    getItemByIndex(index?: string): {
+        key: number;
+        item: ListDataItem;
+    } | undefined;
+    getItemByKey(key: number): ListDataItem | undefined;
+    getFirstItemByParent(parent: string | undefined): ListDataItem | undefined;
+    getLastItemByParent(parent: string | undefined): ListDataItem | undefined;
+    getSubList(item: ListDataItem): ListDataRef;
+}
+
+export declare type ListList<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item>[];
+
+export declare type ListListInput<Item extends ListDataBasic = ListDataBasic> = ListListInputItem<Item>[] | string[] | Record<string, ListListInputItem<Item>> | Record<string, string>;
+
+export declare type ListListInputItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item>;
+
+export declare type ListName = string | number | undefined;
+
+export declare type ListNames = ListName[];
+
+export declare type ListRecord<Item extends ListDataBasic = ListDataBasic> = ListList<Item> | Record<string, any>;
+
+export declare type ListSelectedItem = NumberOrStringOrBoolean;
+
+export declare type ListSelectedList = ListSelectedItem | ListSelectedItem[];
+
+export declare type ListType = 'item' | 'space' | 'line' | 'subtitle' | 'html' | 'menu' | 'menu-group' | 'group';
+
+/** Vue raw children union. */
+export declare type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
+
+/** Vue raw slots object. */
+export declare type RawSlots = {
+    [name: string]: unknown;
+    $stable?: boolean;
+};
+
+/** Type supporting Ref or raw value. */
+export declare type RefOrNormal<T> = RefType<T> | T;
+
+/** Ref or ComputedRef union. */
+export declare type RefType<T> = ComputedRef<T> | Ref<T>;
+
+/** Optional Ref union. */
+export declare type RefUndefined<T> = RefType<T | undefined>;
+
+/** Render cached immutable data. */
+export declare function render<T extends ItemList>(name: string | any, props?: T, children?: RawChildren | RawSlots, index?: string): VNode;
+
+/** Router navigation and link utility. */
+export declare class RouterItemRef {
+    static get(): Router;
+    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;
+}
+
+/** Reactive scrollbar width. */
+export declare class ScrollbarWidthRef {
+    readonly item: Ref<boolean | undefined, boolean | undefined>;
+    readonly width: Ref<number, number>;
+    constructor();
+    readonly is: ComputedRef<boolean>;
+}
+
+export declare type SearchListInput<T extends SearchItem> = SearchListValueRef<T> | (() => SearchListValueRef<T>);
+
+export declare type SearchListValueRef<T extends SearchItem> = RefOrNormal<SearchListValue<T>>;
+
+/** Set global conditions for API requests. */
+export declare const setApiRefGlobalConditions: (conditions: RefType<any>) => void;
+
+/** Update Ref value. */
+export declare function setRef<T>(item: Ref<T>, value: T): void;
+
+/** Shorthand for useTranslateRef. Use 'as const' for arrays. */
+export declare const t: <T extends string[]>(names: T) => ShallowRef<TranslateList<T>>;
+
+/** Merges objects preserving classes/styles. */
+export declare function toBind<R extends ItemList = ItemList>(extra: ItemList, value: ItemList): ConstrBind<R>;
+
+/** Merges multiple objects preserving classes/styles. */
+export declare function toBinds<R extends ItemList = ItemList>(...values: (ItemList | undefined)[]): ConstrBind<R>;
+
+/** Ensures value is wrapped in a Ref. */
+export declare function toRefItem<T>(item: RefOrNormal<T>): Ref<T>;
+
+export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+/** API DELETE request hook. */
+export declare function useApiDelete<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(path?: RefOrNormal<string | undefined>, action?: (data: Return | undefined) => Promise<void> | void, transformation?: (data: T) => Return, toData?: boolean, options?: ApiOptions, apiInstance?: ApiInstance): {
+    loading: Ref<boolean, boolean>;
+    send(request?: Request | undefined): Promise<Return | undefined>;
+};
+
+/** API GET request hook. */
+export declare function useApiGet<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(path?: RefOrNormal<string | undefined>, action?: (data: Return | undefined) => Promise<void> | void, transformation?: (data: T) => Return, toData?: boolean, options?: ApiOptions, apiInstance?: ApiInstance): {
+    loading: Ref<boolean, boolean>;
+    send(request?: Request | undefined): Promise<Return | undefined>;
+};
+
+/**
+ * Orchestrates API loading (GET), formatting, searching, and mutations (POST/PUT/DELETE).
+ * @note Use with `executeUse` for central state.
+ * @remarks Recommended for formatting values (prices, dates) but not technical IDs.
+ * @example
+ * const products = useApiManagementRef({ path: '/api/v1/products' }, { price: (v) => `${v}$` });
+ */
+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>;
+    list: ComputedRef<SearchFormatList<ItemFormatters, Columns>>;
+    readonly data: ComputedRef<ApiData<Return> | undefined>;
+    readonly length: ComputedRef<number>;
+    lengthData: ComputedRef<number>;
+    starting: ComputedRef<boolean>;
+    reading: Ref<boolean, boolean>;
+    loading: Ref<boolean, boolean>;
+    loadingSearch: Ref<boolean, boolean> | undefined;
+    loadingPost: Ref<boolean, boolean> | undefined;
+    loadingPut: Ref<boolean, boolean> | undefined;
+    loadingDelete: Ref<boolean, boolean> | undefined;
+    isSearch: ComputedRef<boolean> | undefined;
+    search: Ref<string, string> | undefined;
+    reset: () => Promise<void>;
+    abort: () => void;
+    sendPost: (request?: ApiFetch["request"]) => Promise<ApiData<Post> | undefined>;
+    sendPut: (request?: ApiFetch["request"]) => Promise<ApiData<Put> | undefined>;
+    sendDelete: (request?: ApiFetch["request"]) => Promise<ApiData<Delete> | undefined>;
+};
+
+/** API POST request hook. */
+export declare function useApiPost<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(path?: RefOrNormal<string | undefined>, action?: (data: Return | undefined) => Promise<void> | void, transformation?: (data: T) => Return, toData?: boolean, options?: ApiOptions, apiInstance?: ApiInstance): {
+    loading: Ref<boolean, boolean>;
+    send(request?: Request | undefined): Promise<Return | undefined>;
+};
+
+/** API PUT request hook. */
+export declare function useApiPut<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(path?: RefOrNormal<string | undefined>, action?: (data: Return | undefined) => Promise<void> | void, transformation?: (data: T) => Return, toData?: boolean, options?: ApiOptions, apiInstance?: ApiInstance): {
+    loading: Ref<boolean, boolean>;
+    send(request?: Request | undefined): Promise<Return | undefined>;
+};
+
+/** Return type for useApiRef. */
+export declare interface UseApiRef<R> {
+    data: ComputedRef<ApiData<R> | undefined>;
+    item: Ref<ApiData<R> | 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;
+    reset(): Promise<void>;
+    stop(): void;
+    abort(): void;
+}
+
+/** Reactive request handling hook. */
+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, unmounted?: boolean, apiInstance?: ApiInstance): UseApiRef<R>;
+
+/** Generic API request hook. */
+export declare function useApiRequest<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(path?: RefOrNormal<string | undefined>, method?: ApiMethodItem, action?: (data: Return | undefined) => Promise<void> | void, transformation?: (data: T) => Return, toData?: boolean, options?: ApiOptions, apiInstance?: ApiInstance): {
+    loading: Ref<boolean, boolean>;
+    send(request?: Request): Promise<Return | undefined>;
+};
+
+/** Reactive value sync across tabs. */
+export declare function useBroadcastValueRef<T>(name: string, defaultValue?: T | string | (() => (T | string))): Ref<BroadcastValueItem<T>>;
+
+/** Reactive cookie management. */
+export declare function useCookieRef<T>(name: string, defaultValue?: T | string | (() => (T | string)), options?: CookieOptions): Ref<T | string | undefined>;
+
+/** Reactive list formatting based on property rules. */
+export declare function useFormattersRef<Options extends FormattersOptionsList = FormattersOptionsList, List extends FormattersListProp = FormattersListProp>(list: RefType<List | undefined>, options: Options): {
+    listFormat: ComputedRef<FormattersReturn<List, Options>>;
+    length: ComputedRef<number>;
+};
+
+/** Returns GeoIntlRef instance. */
+export declare function useGeoIntlRef(): GeoIntlRef;
+
+/** Reactive URL hash management. */
+export declare function useHashRef<T>(name: string, defaultValue?: T | (() => T)): ShallowRef<T>;
+
+/** Track element appearance by margin. */
+export declare const useLazyItemByMarginRef: (element: RefType<HTMLElement | undefined>, rootMargin: string) => {
+    lazyItemStatus: any;
+    readonly lazyItem: any;
+};
+
+/** Generic visibility tracking hook. */
+export declare const useLazyRef: (options?: IntersectionObserverInit) => {
+    intersectionObserver: IntersectionObserver | undefined;
+    getItem(element: HTMLElement): LazyItem;
+    addLazyItem(element: Ref<HTMLElement | undefined>): ShallowRef<boolean, boolean>;
+    removeLazyItem: (element?: HTMLElement) => void;
+    disconnectLazy: () => void | undefined;
+};
+
+/** Returns loading status Ref. */
+export declare function useLoadingRef(): ShallowRef<boolean, boolean>;
+
+/** Reactive meta tag manager with DOM sync. */
+export declare const useMeta: () => Readonly<{
+    meta: Meta;
+    title: Ref<string, string>;
+    keyword: Ref<string, string>;
+    description: Ref<string, string>;
+    author: Ref<string, string>;
+    image: Ref<string, string>;
+    canonical: Ref<string, string>;
+    robots: Ref<MetaRobots, MetaRobots>;
+    siteName: Ref<string, string>;
+    getHtmlMeta: () => string;
+    setSuffix: (suffix: string) => void;
+} & {
+    init(): Readonly<{
+        meta: Meta;
+        title: Ref<string, string>;
+        keyword: Ref<string, string>;
+        description: Ref<string, string>;
+        author: Ref<string, string>;
+        image: Ref<string, string>;
+        canonical: Ref<string, string>;
+        robots: Ref<MetaRobots, MetaRobots>;
+        siteName: Ref<string, string>;
+        getHtmlMeta: () => string;
+        setSuffix: (suffix: string) => void;
+    }>;
+    destroyExecute?(): void;
+}>;
+
+/** Router link list manager. */
+export declare const useRouterList: <T extends ListDataBasic>(list: RefType<ConstrBind<T>[] | undefined>, selected?: Ref<string> | string, hasTo?: boolean) => {
+    item: ComputedRef<T | undefined>;
+    selected: Ref<string, string>;
+    label: ComputedRef<NumberOrString>;
+    list: ComputedRef<ConstrBind<T>[]>;
+    to: (name?: string) => void;
+    toMain(): void;
+};
+
+/** Reactive search logic hook. */
+export declare function useSearchRef<T extends SearchItem, K extends SearchColumns<T>>(list: SearchListInput<T>, columns: K, value?: Ref<string>, options?: SearchOptions): {
+    isSearch: ComputedRef<boolean>;
+    search: Ref<string, string>;
+    loading: Ref<boolean, boolean>;
+    listSearch: ComputedRef<SearchFormatList<T, K>>;
+    length: ComputedRef<number>;
+};
+
+/** Manages search value with debounce/delay. */
+export declare function useSearchValueRef<T extends SearchItem, K extends SearchColumns<T>>(item: SearchList<T, K>, value?: Ref<string>): {
+    search: Ref<string, string>;
+    searchDelay: Ref<string, string>;
+    loading: Ref<boolean, boolean>;
+};
+
+/** Reactive session storage manager. */
+export declare function useSessionRef<T>(name: string, defaultValue?: T | (() => T)): Ref<T | undefined>;
+
+/** Reactive local storage manager. */
+export declare function useStorageRef<T>(name: string, defaultValue?: T | (() => T), cache?: number): Ref<T | undefined>;
+
+/**
+ * Returns reactive translation list. Updates on language change.
+ * @example
+ * const t = useTranslateRef(['home.title'] as const);
+ */
+export declare function useTranslateRef<T extends (string | string[])[]>(names: T, translateInstance?: TranslateInstance): ShallowRef<TranslateList<T>>;
+
+export * from "@dxtmisha/functional-basic";
+export { }
+
+go!