@dxtmisha/functional 1.15.5 → 1.15.7

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.15.7] - 2026-08-05
+
+### Changed
+- **AI Documentation**: Modularized package documentation and generated `ai-mcp.json` resource definitions alongside updated `ai-description.md` and `ai-types.md`.
+
+## [1.15.6] - 2026-07-28
+
+### Changed
+- **GeoIntlRef & useGeoIntlRef**: Added JSDoc `@remarks` guidelines recommending the use of standard non-reactive `GeoIntl` from `@dxtmisha/functional-basic` when reactivity is not required.
+- **Documentation**: Updated AI documentation context (`ai-description.md`, `ai-types.md`) and package type definitions.
+
 ## [1.15.5] - 2026-07-25
 
 ### Added

package/ai-description.md

@@ -1,29 +1,7 @@
-1. CORE PURPOSE
-This library (@dxtmisha/functional) provides Vue 3 reactive abstractions, abstract base classes for component architecture, and advanced composables. It elevates low-level functional utilities from @dxtmisha/functional-basic into Vue 3 reactivity system (refs, computed, lifecycle, reactive singletons) to handle REST API orchestration, localization, meta management, routing, client-side storage, lazy loading, list/search data structures, and standard component state construction.
-
-2. KEY EXPOSITIONS
-Abstract Component Base Classes: DesignAbstract, DesignAsyncAbstract, DesignChanged, DesignComponents, DesignComp, DesignConstructorAbstract. These manage component state lifecycle, dynamic class and style processing, event hooks, slot rendering, component modifications, and property mutation tracking.
-
-Reactive API Composables: useApiRef, useApiAsyncRef, useApiManagementRef, useApiManagementAsyncRef, useApiGet, useApiPost, useApiPut, useApiDelete, useApiRequest. These handle REST operations with SSR prefetching, response contract validation, mutation handling, error contract mapping, client-side pagination/filtering, and automatic state reactivity.
-
-Singleton State & Execution Control: executeUse, executeUseGlobal, executeUseProvide, executeUseLocal, executeUseGlobalInit. These encapsulate factory initialization into global, component-tree inject/provide, or closure-local singletons.
-
-Localization & Formatting Classes and Composables: DatetimeRef, GeoFlagRef, GeoIntlRef, GeoRef, GeoUnitRef, useGeoIntlRef, useGeoUnitRef, useFormattersRef, useTranslateRef, t. These offer reactive locale-aware date/time formatting, unit conversion, flag retrieval, and multi-key translation refs.
-
-Data Structures & UI Management: ListDataRef, useRouterList, useSearchRef, useSearchValueRef, useLazyRef, useLazyItemByMarginRef, ScrollbarWidthRef, EventRef, EffectScopeGlobal. These provide reactive list data mapping, search query debounce and highlighting, lazy-loading via IntersectionObserver, scrollbar width tracking, and global effect scopes.
-
-State Persistence & Browser Composables: useBroadcastValueRef, useCookieRef, useHashRef, useQueryRef, useSessionRef, useStorageRef, useMeta. These control cross-tab communication, cookies, URL query/hash reactive synchronization, session/local storage, and reactive HTML document metadata.
-
-Utility Functions & Plugin: computedAsync, computedByLanguage, computedEternity, getBind, getBindRef, render, toBind, toBinds, dxtFunctionalPlugin.
-
-3. TRIGGERS FOR STUDYING AI-TYPES.MD
-Reading ai-types.md is mandatory under any of the following conditions, keywords, or implementation tasks:
-- Extending or sub-classing DesignConstructorAbstract, DesignAbstract, DesignAsyncAbstract, or DesignComponents.
-- Configuring API integrations requiring complex typing, specifically ApiManagementGet, ApiManagementSearch, ApiManagementRequest, or ApiOptions.
-- Utilizing component metadata and binding types, such as ConstrBind, ConstrClasses, ConstrStyles, ConstrOptions, ConstrSetup, ConstrComponentMod, or ConstrProps.
-- Constructing managed singletons using executeUse, executeUseGlobal, executeUseProvide, or executeUseLocal.
-- Typing complex list inputs, search items, and reactive parameters using ListList, ListDataItem, ListDataFull, RefOrNormal, RefType, or RefOrNormalOrFunction.
-- Implementing contract validation functions (validateResponseContract, validateRequestContract) or error contracts (ApiErrorStorageList) with schema validation libraries.
-
-4. INTEGRATION CONTEXT
-Initializes as a Vue 3 plugin via dxtFunctionalPlugin. Connects directly with Vue 3 reactivity and rendering APIs (ref, computed, VNode, provide/inject). Wraps base functional logic from @dxtmisha/functional-basic, integrates with vue-router via RouterItemRef, links to @dxtmisha/media for social icons, and supports runtime schema validation (such as @effect/schema) inside API payload contracts.
+This library is a reactive utility and component architecture framework for Vue 3 that standardizes design system component construction, locale-aware data formatting, browser storage state, and API request lifecycle orchestration. It provides abstract component models for computing styles, classes, slots, and properties, alongside wrappers for reactive state synchronization and dynamic component rendering. Design System Architecture components abstractly encapsulate Vue component structures, automating class and style generation, property change detection, slot bindings, and dynamic component rendering. API and Network Management modules manage asynchronous HTTP request lifecycles, server-side prefetching, CRUD mutations, response contract validation, error handling, and unified client-side search or formatting pipelines. Localization and Formatting utilities deliver reactive interfaces for internationalized formatting of dates, currencies, numbers, measurement units, country flag metadata, and dynamic translation lists. Storage and State controls wrap browser local storage, session storage, cookies, broadcast channels, and URL query or hash parameters into reactive references. List and Search utilities provide reactive controllers for hierarchical list filtering, multi-item selection tracking, focus navigation, and debounced text searches. DOM and Lifecycle controls manage intersection observers for lazy loading, document head metadata, scrollbar dimensions, global loading state tracking, and reactive event listeners. Injection and Singleton utilities support managed lifecycle topologies across application, component-subtree, or closure scopes. Studying ai-types.md is mandatory when implementing custom component constructors extending base design abstract classes, defining request or response validation contracts, configuring complex API management options, typing list data inputs and selection states, setting up functional plugin options, or establishing singleton execution topologies. The library integrates directly with Vue 3 reactivity and SSR runtime paradigms, Vue Router navigation mechanisms, and core functional utility packages.
+## Mandatory Rules
+Read the corresponding file if your task relates to:
+- 'node_modules/@dxtmisha/functional/ai-prompts/api-reference.md': Scope factory initialization, reactive singletons, and REST API management patterns
+- 'node_modules/@dxtmisha/functional/ai-prompts/localization-seo.md': Geographic context, internationalization formatting, translation utilities, HTML metadata management, and scrollbar measurement
+- 'node_modules/@dxtmisha/functional/ai-prompts/reactivity-lists.md': Async reactivity helpers, list management, search filtering, and DOM event observers
+- 'node_modules/@dxtmisha/functional/ai-prompts/storage-state.md': Reactive composables for persistent browser storage, cookies, broadcast messaging, and URL hashes

package/ai-doc.md

@@ -1,42 +1,8 @@
 # @dxtmisha/functional Reference
-Vue 3 reactive utilities built on `@dxtmisha/functional-basic`. See `ai-types.md` for full signatures.
-
-## Usage Rules & Strategies
-- **Priority**: Always use this package over `@dxtmisha/functional-basic` in Vue.
-- **API/State Singletons**: **NEVER** call `useApi*` / `executeUse*` hooks directly in Vue components. Wrap them in `executeUseGlobal` (startup), `executeUseLocal` (lazy, session scope), or `executeUseProvide` (scoped tree) inside external service files. Components only import and call the resulting hook.
-
-```typescript
-import { executeUseLocal, useApiManagementRef, useStorageRef, useSessionRef, useCookieRef, useBroadcastValueRef, useHashRef, GeoRef, useGeoIntlRef, useTranslateRef, useMeta, ScrollbarWidthRef, computedAsync, computedEternity, ListDataRef, useSearchRef, EventRef, useLazyRef } from '@dxtmisha/functional';
-
-// 1. API Management
-export const useUsers = executeUseLocal(() => useApiManagementRef(
-  { path: '/api/users' }, { date: (v) => new Date(v).toLocaleString() }, { columns: ['name'] },
-  { path: '/api/users' }, { path: (o) => `/api/users/${o.id}` }, { path: (o) => `/api/users/${o.id}` }
-));
-
-// 2. Storage & State
-const theme = useStorageRef<'light' | 'dark'>('theme', 'light');
-const step = useSessionRef<number>('step', 1);
-const token = useCookieRef<string>('auth', '', { secure: true });
-const sync = useBroadcastValueRef<string>('ch', 'idle');
-const page = useHashRef<string>('page', 'home');
 
-// 3. Geo & Formatting
-const country = GeoRef.getCountry(); const intl = useGeoIntlRef(); intl.currency(150, 'EUR');
-const t = useTranslateRef(['global.save']);
-
-// 4. SEO & Layout
-useMeta().setTitle('Page'); const scrollW = new ScrollbarWidthRef().width;
-
-// 5. Reactivity Helpers
-const asyncData = computedAsync(async () => fetch(), 'loading...');
-const cached = computedEternity(async () => fetch(), 'loading...');
-
-// 6. Lists & Search
-const list = new ListDataRef(items, selectedId); list.isSelected;
-const { listSearch } = useSearchRef(items, ['label'], ref('query'));
+Vue 3 reactive utilities built on `@dxtmisha/functional-basic`. See `ai-types.md` for full signatures.
 
-// 7. DOM Events & Lazy
-const listener = new EventRef(window, window, 'keydown', (e) => console.log(e.key));
-const lazy = useLazyRef(); lazy.addLazyItem(elementRef);
-```
+## Core Architectural Rules & Strategies
+- **Priority**: Always use `@dxtmisha/functional` reactive composables instead of low-level `@dxtmisha/functional-basic` primitives in Vue 3 applications.
+- **API & State Singletons**: **NEVER** call `useApi*` / `executeUse*` hooks directly in Vue components (`<script setup>`). Wrap them in `executeUseGlobal` (startup), `executeUseLocal` (lazy, session scope), or `executeUseProvide` (scoped tree) inside external service files. Components only import and call the resulting hook.
+- **Purity & Atomicity**: Keep Vue components minimal. Extract all reactive state management, network orchestration, and side effects into external composables.

package/ai-mcp.json

@@ -0,0 +1,38 @@
+[
+  {
+    "uri": "@dxtmisha/functional/ai-types.md",
+    "name": "Vue Functional Reference",
+    "mimeType": "text/markdown",
+    "description": "TypeScript type definitions and composable API specifications for Vue application state management, data formatting, localization, and API request handling."
+  },
+  {
+    "uri": "@dxtmisha/functional/ai-description.md",
+    "name": "Vue Framework Architecture",
+    "mimeType": "text/markdown",
+    "description": "Comprehensive architectural conventions and guidelines for a Vue 3 reactive utility framework, covering component construction, API lifecycle management, localization, and persistent state controls."
+  },
+  {
+    "uri": "@dxtmisha/functional/ai-prompts/api-reference.md",
+    "name": "API Reference",
+    "mimeType": "text/markdown",
+    "description": "Defines architectural patterns and usage guidelines for REST API management and scope-isolated reactive singletons within @dxtmisha/functional. Details scope factory initialization alongside reactive CRUD operations with client-side caching and contract validation."
+  },
+  {
+    "uri": "@dxtmisha/functional/ai-prompts/localization-seo.md",
+    "name": "Localization and SEO",
+    "mimeType": "text/markdown",
+    "description": "Covers locale-aware formatting, multi-key translations, geographic context management, and reactive HTML document metadata handling for SEO optimization."
+  },
+  {
+    "uri": "@dxtmisha/functional/ai-prompts/reactivity-lists.md",
+    "name": "Reactivity and Lists",
+    "mimeType": "text/markdown",
+    "description": "Comprehensive guide to advanced asynchronous reactivity composables, list data models, multi-field search filtering, and DOM observer utilities."
+  },
+  {
+    "uri": "@dxtmisha/functional/ai-prompts/storage-state.md",
+    "name": "Reactive Browser State",
+    "mimeType": "text/markdown",
+    "description": "API reference and usage examples for reactive composables managing persistent browser state and cross-tab synchronization. Covers localStorage, sessionStorage, cookies, BroadcastChannel, and URL hash state."
+  }
+]

package/ai-prompts/api-reference.md

@@ -0,0 +1,25 @@
+# API Management & Reactive Singletons
+
+Guidance and usage patterns for REST API management and scope-isolated singleton factories in `@dxtmisha/functional`.
+
+## 1. Scope Factory Initialization (`executeUse*`)
+- **`executeUseGlobal`**: Initializes a global singleton instance at application startup (shared across the entire application).
+- **`executeUseLocal`**: Lazily creates a session-scoped or closure-local instance upon first invocation.
+- **`executeUseProvide`**: Scope-bound singleton bound to a specific component subtree via Vue `provide` / `inject`.
+
+## 2. API Management (`useApiManagementRef`)
+Handles REST CRUD operations with built-in reactivity, client-side caching, filtering, and contract validation.
+
+### Example
+```typescript
+import { executeUseLocal, useApiManagementRef } from '@dxtmisha/functional';
+
+export const useUsers = executeUseLocal(() => useApiManagementRef(
+  { path: '/api/users' },
+  { date: (v: string) => new Date(v).toLocaleString() },
+  { columns: ['name', 'email'] },
+  { path: '/api/users' },
+  { path: (o) => `/api/users/${o.id}` },
+  { path: (o) => `/api/users/${o.id}` }
+));
+```

package/ai-prompts/localization-seo.md

@@ -0,0 +1,29 @@
+# Localization, Geo & SEO Management
+
+Locale-aware formatting, translation primitives, and reactive HTML document metadata handling.
+
+## Available Utilities
+- **`GeoRef`**: Access country information and geographic context (`GeoRef.getCountry()`).
+- **`useGeoIntlRef()`**: Reactive internationalization helper for currency, numbers, and dates.
+- **`useTranslateRef(keys)`**: Multi-key reactive translation resolver.
+- **`useMeta()`**: Reactive manager for HTML document title, meta tags, and open graph social tags.
+- **`ScrollbarWidthRef`**: Helper to measure dynamic scrollbar width for fixed overlay calculations.
+
+### Example
+```typescript
+import {
+  GeoRef,
+  useGeoIntlRef,
+  useTranslateRef,
+  useMeta,
+  ScrollbarWidthRef
+} from '@dxtmisha/functional';
+
+const country = GeoRef.getCountry();
+const intl = useGeoIntlRef();
+intl.currency(150, 'EUR');
+
+const t = useTranslateRef(['global.save']);
+useMeta().setTitle('User Dashboard');
+const scrollW = new ScrollbarWidthRef().width;
+```

package/ai-prompts/reactivity-lists.md

@@ -0,0 +1,34 @@
+# Reactivity Helpers, Lists & DOM Utilities
+
+Advanced async reactivity, list data models, search filters, and DOM observers.
+
+## Available Composables & Classes
+- **`computedAsync(evaluator, defaultVal)`**: Asynchronous computed reference for promise resolution.
+- **`computedEternity(evaluator, defaultVal)`**: Cached asynchronous computed ref that preserves state across re-evaluations.
+- **`ListDataRef(items, selectedId)`**: Reactive list structure supporting selection state management.
+- **`useSearchRef(items, fields, queryRef)`**: Debounced multi-field search and highlighting composable.
+- **`EventRef(target, element, event, callback)`**: Managed DOM event listener with automatic lifecycle cleanup.
+- **`useLazyRef()`**: IntersectionObserver helper for lazy rendering and dynamic element loading.
+
+### Example
+```typescript
+import { ref } from 'vue';
+import {
+  computedAsync,
+  computedEternity,
+  ListDataRef,
+  useSearchRef,
+  EventRef,
+  useLazyRef
+} from '@dxtmisha/functional';
+
+const asyncData = computedAsync(async () => fetch('/api/data').then(r => r.json()), 'loading...');
+const cachedData = computedEternity(async () => fetch('/api/cached').then(r => r.json()), 'loading...');
+
+const list = new ListDataRef(items, selectedId);
+const query = ref('');
+const { listSearch } = useSearchRef(items, ['name', 'description'], query);
+
+const listener = new EventRef(window, window, 'keydown', (e) => console.log(e.key));
+const lazy = useLazyRef();
+```

package/ai-prompts/storage-state.md

@@ -0,0 +1,27 @@
+# Reactive Storage & Browser State
+
+Composable wrappers for persistent and synchronized browser state management.
+
+## Available Composables
+- **`useStorageRef<T>(key, defaultVal)`**: Reactive `localStorage` wrapper with cross-tab synchronization.
+- **`useSessionRef<T>(key, defaultVal)`**: Reactive `sessionStorage` wrapper for session-scoped data.
+- **`useCookieRef<T>(key, defaultVal, options)`**: SSR-safe reactive cookie state wrapper.
+- **`useBroadcastValueRef<T>(channel, defaultVal)`**: Reactive cross-tab broadcast messaging using `BroadcastChannel`.
+- **`useHashRef<T>(key, defaultVal)`**: Reactive synchronization with URL hash fragments.
+
+### Example
+```typescript
+import {
+  useStorageRef,
+  useSessionRef,
+  useCookieRef,
+  useBroadcastValueRef,
+  useHashRef
+} from '@dxtmisha/functional';
+
+const theme = useStorageRef<'light' | 'dark'>('theme', 'light');
+const step = useSessionRef<number>('step', 1);
+const token = useCookieRef<string>('auth', '', { secure: true });
+const sync = useBroadcastValueRef<string>('ch', 'idle');
+const page = useHashRef<string>('page', 'home');
+```

package/ai-types.md

@@ -1,20 +1,138 @@
 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"
-  }
-}
 
+import { ComputedRef, Ref, ShallowRef, ToRefs, VNode, DebuggerOptions, ComputedGetter, PropType, VNodeArrayChildren, Plugin } from 'vue';
+import { RouteLocationRaw, Router, _RouterClassic } from 'vue-router';
+import { InputSocialIcons } from '@dxtmisha/media';
+import { Datetime, GeoDate, GeoFirstDay, GeoHours, NumberOrStringOrDate, ElementOrString, ElementOrWindow, EventItem, EventListenerDetail, EventOptions, GeoFlag, GeoFlagItem, GeoFlagNational, ItemValue, NumberOrString, GeoItemFull, GeoUnit, ApiInstance, ApiData, ApiDataValidation, ApiErrorStorageList, ApiFetch, ArrayToItem, FormattersListColumns, FormattersOptionsList, SearchColumns, SearchFormatList, ApiErrorItem, FormattersListProp, FormattersReturn, MetaRobots, Meta, SearchItem, SearchOptions, TranslateInstance, TranslateList, ApiConfig, ErrorCenterCauseList, ErrorCenterHandlerCallback, ErrorCenterHandlerList, IconsConfig, TranslateConfig, Undefined, NumberOrStringOrBoolean, ApiDefaultValue, SearchListValue, ItemList, ApiMethodItem } from '@dxtmisha/functional-basic';
 export * from '@dxtmisha/functional-basic';
+export type ApiOptions = ApiMethodItem | RefOrNormal<ApiFetch>;
+export type ApiManagementValue = ApiDefaultValue | ApiDefaultValue[];
+export type ApiManagementGet<Return extends ApiManagementValue, Type extends ApiManagementValue = Return> = {
+    path?: RefOrNormal<string | undefined>;
+    options?: ApiOptions;
+    reactivity?: boolean;
+    conditions?: RefType<boolean>;
+    transformation?: (data: Type, isResponseContractValid?: ApiDataValidation) => ApiData<Return>;
+    validateResponseContract?: (data: Type) => ApiDataValidation;
+    errorContract?: ApiErrorStorageList;
+    typeData?: ((data: Return) => boolean) | any;
+    unmounted?: boolean;
+    skeleton?: () => Return;
+};
+export type ApiManagementSearch<T extends SearchItem, K extends SearchColumns<T>> = {
+    columns: K;
+    value?: Ref<string>;
+    options?: SearchOptions;
+};
+export type ApiManagementRequest<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> = {
+    path?: RefOrNormal<string | undefined>;
+    action?: (data: Return | undefined) => Promise<void> | void;
+    transformation?: (data: T) => Return;
+    validateRequestContract?: (data: Request) => ApiDataValidation & Return;
+    validateResponseContract?: (data: T) => ApiDataValidation & Return;
+    errorContract?: ApiErrorStorageList;
+    toData?: boolean;
+    options?: ApiOptions;
+};
+export type ConstrItem = Record<string, any>;
+export type ConstrValue<T = any> = {
+    value?: T;
+};
+export type ConstrComponent = Record<string, any>;
+export type ConstrComponentMod<P extends ConstrItem> = ConstrItem | {
+    [K in keyof P]?: RefOrNormal<P[K]>;
+};
+export type ConstrExpose<E extends Element, EXPOSE extends ConstrItem> = EXPOSE & {
+    elementHtml?: ComputedRef<E | undefined>;
+};
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type ConstrEmitItem<T extends ConstrItem> = T[keyof T];
+export type ConstrEmit<T extends ConstrItem = ConstrItem> = UnionToIntersection<ConstrEmitItem<{
+    [K in keyof T]: (evt: K, ...args: T[K]) => void;
+}>>;
+export type ConstrClassObject = Record<string, boolean | undefined>;
+export type ConstrClass = string | (string | ConstrClass | Undefined)[] | ConstrClassObject;
+export type ConstrClassList = Record<string, ConstrClass>;
+export type ConstrClasses = {
+    main: ConstrClass;
+} & ConstrClassList;
+export type ConstrStylesItem = string | null;
+export type ConstrStyles = Record<string, ConstrStylesItem> | ConstrStyles[];
+export type ConstrOptions<COMP extends ConstrComponent, EMITS extends ConstrItem, P extends ConstrItem> = {
+    components?: COMP;
+    compMod?: ConstrComponentMod<P>;
+    emits?: ConstrEmit<EMITS>;
+    classes?: RefType<ConstrClasses>;
+    styles?: RefType<ConstrStyles>;
+};
+export type ConstrSetup<E extends Element, CLASSES extends ConstrClasses, SETUP extends ConstrItem> = {
+    name: string;
+    element: Ref<E | undefined>;
+    classes: RefType<CLASSES>;
+    styles: RefType<ConstrStyles>;
+} & SETUP;
+export type ConstrRegistration = {
+    flag?: boolean;
+    translate?: Record<string, string>;
+};
+export type ConstrBind<T> = T & Record<string, any> & {
+    key?: string;
+    class?: ConstrClass;
+    style?: ConstrStyles;
+};
+export type ConstrPropItemOptions<T = any> = {
+    type?: PropType<T>;
+    required?: boolean;
+    default?: any;
+    validator?(value: any, props: any): boolean;
+};
+export type ConstrPropItem<T = any> = ConstrPropItemOptions<T> | PropType<T>;
+export type ConstrProps<P = Record<string, any>> = {
+    [K in keyof P]: ConstrPropItem<P[K]>;
+};
+export type ConstrHrefProps = {
+    href?: string;
+};
+export type ListType = 'item' | 'space' | 'line' | 'subtitle' | 'html' | 'menu' | 'menu-group' | 'group';
+export type ListDataBasic = {
+    label?: NumberOrString;
+    value?: any;
+    search?: string;
+};
+export type ListDataItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item & {
+    parent?: string;
+    type: ListType;
+    index: string;
+    disabled?: boolean;
+}>;
+export type ListList<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item>[];
+export type ListRecord<Item extends ListDataBasic = ListDataBasic> = ListList<Item> | Record<string, any>;
+export type ListDataFullItem<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item> & {
+    focus: boolean;
+    highlight?: string;
+    selected: boolean;
+    disabled?: boolean;
+};
+export type ListDataFull<Item extends ListDataBasic = ListDataBasic> = ListDataFullItem<Item>[];
+export type ListListInputItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item>;
+export type ListListInput<Item extends ListDataBasic = ListDataBasic> = ListListInputItem<Item>[] | string[] | Record<string, ListListInputItem<Item>> | Record<string, string>;
+export type ListSelectedItem = NumberOrStringOrBoolean;
+export type ListSelectedList = ListSelectedItem | ListSelectedItem[];
+export type ListName = string | number | undefined;
+export type ListNames = ListName[];
+export type RefType<T> = ComputedRef<T> | Ref<T>;
+export type RefUndefined<T> = RefType<T | undefined>;
+export type RefOrNormal<T> = RefType<T> | T;
+export type RefOrNormalOrFunction<T> = RefOrNormal<T> | (() => RefOrNormal<T>);
+export type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
+export type RawSlots = {
+    [name: string]: unknown;
+    $stable?: boolean;
+};
+export type SearchListValueRef<T extends SearchItem> = RefOrNormal<SearchListValue<T>>;
+export type SearchListInput<T extends SearchItem> = SearchListValueRef<T> | (() => SearchListValueRef<T>);
+export type SearchColumnsRef<T extends SearchItem, K extends SearchColumns<T>> = RefOrNormal<K>;
+export type SearchColumnsInput<T extends SearchItem, K extends SearchColumns<T>> = SearchColumnsRef<T, K> | (() => SearchColumnsRef<T, K>);
 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[]);
     make(compelled?: boolean): this;
@@ -30,7 +148,8 @@ export declare class DesignChanged<T extends Record<string, any>> {
     isChanged(): boolean;
     update(): void;
 }
-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> {
+}
 export declare class DesignComponents<COMP extends ConstrComponent, P extends ConstrItem> {
     constructor(components?: COMP, modification?: ConstrComponentMod<P> | undefined);
     is<K extends keyof COMP>(name: K): name is K;
@@ -84,6 +203,13 @@ export declare class GeoFlagRef {
     getNational(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
     getNationalLanguage(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
 }
+/**
+ * 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`.
+ */
 export declare class GeoIntlRef {
     constructor(code?: RefOrNormal<string>);
     display(value?: RefOrNormal<string>, typeOptions?: Intl.DisplayNamesOptions['type'] | Intl.DisplayNamesOptions): ComputedRef<string>;
@@ -202,60 +328,24 @@ export declare class ScrollbarWidthRef {
 }
 /**
  * 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' }
- *   ]
- * )
+ * const { data, loading, errorItem } = useApiAsyncRef('/users/1')
  * ```
- *
- * @param path path to request (can be a Ref or Getter)
- * @param options data for the request (headers, method, etc.)
- * @param reactivity should reactivity be enabled (automatically re-fetch on deps change)
- * @param conditions conditions for executing the request (request will wait until true)
- * @param transformation transforms the received response data
- * @param validateResponseContract 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.
- * @param errorContract 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). If an error occurs matching one of these contracts,
- * it will be automatically processed and made available via the `errorItem` computed property.
- * @param unmounted whether to stop the request and clear data from cache when component is unmounted
- * @param apiInstance Api instance (defaults to global Api instance)
  */
 export declare function useApiAsyncRef<R, T = R>(path?: RefOrNormal<string | undefined>, options?: ApiOptions, reactivity?: boolean, conditions?: RefType<boolean>, transformation?: (data: T, isResponseContractValid?: ApiDataValidation) => ApiData<R>, validateResponseContract?: (data: T) => ApiDataValidation, errorContract?: ApiErrorStorageList, unmounted?: boolean, apiInstance?: ApiInstance): UseApiRef<R>;
-export interface UseApiDeleteSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {}
+export interface UseApiDeleteSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
+}
 export declare function useApiDelete<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiDeleteSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
-export interface UseApiGetSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {}
+export interface UseApiGetSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
+}
 export declare function useApiGet<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiGetSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
@@ -288,63 +378,24 @@ export declare function useApiManagementAsyncRef<Return extends ApiManagementVal
 };
 /**
  * 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.
+ * @note
+ * This hook is recommended to be used in tandem with `executeUse` for centralized state management.
  *
  * @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.
+ * - Recommended for formatting: Numbers that represent values, dates, currency, units, and statuses.
+ * - Not recommended for formatting: Technical identifiers such as ID, UUID, account numbers, types, or internal codes.
  *
  * @example
- * // 1. Comprehensive API orchestration
+ * ```typescript
  * 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)
+ *   { path: '/api/v1/products' },
+ *   { price: (v) => `${v} USD` },
+ *   { columns: ['name', 'category'] },
+ *   { path: '/api/v1/products' }
  * );
- *
- * // Accessing data:
- * // products.list.value -> processed, formatted, and searched list
- * // products.sendPost({ name: 'New Product', price: 100 }) -> execute mutation
+ * ```
  */
 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>;
@@ -372,12 +423,14 @@ export declare function useApiManagementRef<Return extends ApiManagementValue, F
     sendPut: (request?: ApiFetch["request"]) => Promise<ApiData<Put> | undefined>;
     sendDelete: (request?: ApiFetch["request"]) => Promise<ApiData<Delete> | undefined>;
 };
-export interface UseApiPostSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {}
+export interface UseApiPostSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
+}
 export declare function useApiPost<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiPostSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
-export interface UseApiPutSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {}
+export interface UseApiPutSetup<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> extends Omit<UseApiRequestSetup<T, Request, Return>, 'method'> {
+}
 export declare function useApiPut<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>>(setup: UseApiPutSetup<T, Request, Return>): {
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
@@ -404,53 +457,13 @@ export interface UseApiRef<R> {
 }
 /**
  * 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'
- *     }
- *   ]
- * )
+ * const { data, loading } = useApiRef('/users/1')
  * ```
- *
- * @param path path to request (can be a Ref or Getter)
- * @param options data for the request (headers, method, etc.)
- * @param reactivity should reactivity be enabled (automatically re-fetch on deps change)
- * @param conditions conditions for executing the request (request will wait until true)
- * @param transformation transforms the received response data
- * @param validateResponseContract 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.
- * @param errorContract 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). If an error occurs matching one of these contracts,
- * it will be automatically processed and made available via the `errorItem` computed property.
- * @param unmounted whether to stop the request and clear data from cache when component is unmounted
- * @param apiInstance Api instance (defaults to global Api instance)
  */
 export declare function useApiRef<R, T = R>(path?: RefOrNormal<string | undefined>, options?: ApiOptions, reactivity?: boolean, conditions?: RefType<boolean>, transformation?: (data: T, isResponseContractValid?: ApiDataValidation) => ApiData<R>, validateResponseContract?: (data: T) => ApiDataValidation, errorContract?: ApiErrorStorageList, unmounted?: boolean, apiInstance?: ApiInstance): UseApiRef<R>;
 export declare const setApiRefGlobalConditions: (conditions: RefType<any>) => void;
@@ -470,12 +483,20 @@ export declare function useApiRequest<T, Request extends ApiFetch['request'] = A
     loading: Ref<boolean, boolean>;
     send(request?: Request): Promise<Return | undefined>;
 };
-export declare function useBroadcastValueRef<T>(name: string, defaultValue?: T | string | (() => (T | string))): Ref<T | string | undefined>;
+type BroadcastValueItem<T> = T | string | undefined;
+export declare function useBroadcastValueRef<T>(name: string, defaultValue?: T | string | (() => (T | string))): Ref<BroadcastValueItem<T>>;
 export declare function useCookieRef<T>(name: string, defaultValue?: T | string | (() => (T | string)), options?: CookieOptions): Ref<T | string | undefined>;
 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 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`.
+ */
 export declare function useGeoIntlRef(): GeoIntlRef;
 export declare function useGeoUnitRef(): GeoUnitRef;
 export declare function useHashRef<T>(name: string, defaultValue?: T | (() => T)): ShallowRef<T>;
@@ -551,7 +572,7 @@ export declare const useMeta: () => Readonly<{
         setSuffix: (suffix: string) => void;
     }>;
     destroyExecute?(): void;
-};
+}>;
 export declare function useQueryRef<T>(name: string, defaultValue?: T | (() => T)): ShallowRef<T>;
 export declare const useRouterList: <T extends ListDataBasic>(list: RefType<ConstrBind<T>[] | undefined>, selected?: Ref<string> | string, hasTo?: boolean) => {
     item: ComputedRef<T | undefined>;
@@ -576,30 +597,15 @@ export declare function useSearchValueRef<T extends SearchItem, K extends Search
 export declare function useSessionRef<T>(name: string, defaultValue?: T | (() => T)): Ref<T | undefined>;
 export declare function useStorageRef<T>(name: string, defaultValue?: T | (() => T), cache?: number): Ref<T | undefined>;
 /**
- * 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.
+ * Getting translated text by array of keys or key string.
  *
- * ### Examples:
+ * @example
  * ```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
  */
 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
- */
 export declare const t: <T extends string[]>(names: T) => ShallowRef<TranslateList<T>>;
 export declare const uiMakeFlags: () => void;
 export declare function computedAsync<R>(getter: (() => Promise<R>) | (() => R) | R, initialState?: (() => R) | R, ignore?: R, debugOptions?: DebuggerOptions): ComputedRef<R | undefined>;
@@ -618,21 +624,14 @@ export interface FunctionalPluginOptions {
     errorCallbacks?: ErrorCenterHandlerCallback[];
 }
 /**
- * Vue plugin for initializing and configuring global functional services
- * (Api, Translate, Icons, Meta).
+ * Vue plugin for initializing global functional services.
  *
  * @example
  * ```typescript
  * import { createApp } from 'vue'
  * import { dxtFunctionalPlugin } from '@dxtmisha/functional'
- * import router from './router'
- *
  * const app = createApp(App)
- * app.use(dxtFunctionalPlugin, {
- *   api: { url: 'https://api.example.com' },
- *   metaSuffix: ' | My App',
- *   router
- * })
+ * app.use(dxtFunctionalPlugin, { api: { url: 'https://api.example.com' } })
  * ```
  */
 export declare const dxtFunctionalPlugin: Plugin;
@@ -648,73 +647,15 @@ export type ExecuteUseReturn<R> = Readonly<R & {
 /**
  * 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 {function} 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(() => {
- *   // Reactive logic here
- *   const items = [];
- *   const addItem = (item) => items.push(item);
- *   return { items, addItem };
- * });
- *
- * @example
- * // 3. Local Caching
- * export const useHeavyResource = executeUseLocal((config) => {
- *   return new HeavyResource(config);
- * });
+ * Use this function for API services, resource optimization, shared state, or external SDKs.
  *
  * @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();
+ * ```typescript
+ * 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.
- *
- * @remarks
- * See {@link executeUse} for more details.
- *
- * @param callback Initialization function
- */
 export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<R & {
     init(): Readonly<R>;
     destroyExecute?(): void;
@@ -722,15 +663,6 @@ 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
- */
 export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
     init(): Readonly<R>;
     destroyExecute?(): void;
@@ -738,15 +670,6 @@ 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
- */
 export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
     init(): Readonly<R>;
     destroyExecute?(): void;
@@ -768,132 +691,4 @@ export declare function getBind<T, R extends ItemList>(value: T | R | undefined
 export declare function getClassName<T extends ItemList>(props?: T): string | undefined;
 export declare function getIndexForRender<T extends ItemList>(name: string | any, props?: T, index?: string): string | undefined;
 export declare function toBind<R extends ItemList = ItemList>(extra: ItemList, value: ItemList): ConstrBind<R>;
-export declare function toBinds<R extends ItemList = ItemList>(...values: (ItemList | undefined)[]): ConstrBind<R>;
-export type ApiOptions = ApiMethodItem | RefOrNormal<ApiFetch>;
-export type ApiManagementValue = ApiDefaultValue | ApiDefaultValue[];
-export type ApiManagementGet<Return extends ApiManagementValue, Type extends ApiManagementValue = Return> = {
-    path?: RefOrNormal<string | undefined>;
-    options?: ApiOptions;
-    reactivity?: boolean;
-    conditions?: RefType<boolean>;
-    transformation?: (data: Type, isResponseContractValid?: ApiDataValidation) => ApiData<Return>;
-    validateResponseContract?: (data: Type) => ApiDataValidation;
-    errorContract?: ApiErrorStorageList;
-    typeData?: ((data: Return) => boolean) | any;
-    unmounted?: boolean;
-    skeleton?: () => Return;
-};
-export type ApiManagementSearch<T extends SearchItem, K extends SearchColumns<T>> = {
-    columns: K;
-    value?: Ref<string>;
-    options?: SearchOptions;
-};
-export type ApiManagementRequest<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> = {
-    path?: RefOrNormal<string | undefined>;
-    action?: (data: Return | undefined) => Promise<void> | void;
-    transformation?: (data: T) => Return;
-    validateRequestContract?: (data: Request) => ApiDataValidation & Return;
-    validateResponseContract?: (data: T) => ApiDataValidation & Return;
-    errorContract?: ApiErrorStorageList;
-    toData?: boolean;
-    options?: ApiOptions;
-};
-export type ConstrItem = Record<string, any>;
-export type ConstrValue<T = any> = {
-    value?: T;
-};
-export type ConstrComponent = Record<string, any>;
-export type ConstrComponentMod<P extends ConstrItem> = ConstrItem | {
-    [K in keyof P]?: RefOrNormal<P[K]>;
-};
-export type ConstrExpose<E extends Element, EXPOSE extends ConstrItem> = EXPOSE & {
-    elementHtml?: ComputedRef<E | undefined>;
-};
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-export type ConstrEmitItem<T extends ConstrItem> = T[keyof T];
-export type ConstrEmit<T extends ConstrItem = ConstrItem> = UnionToIntersection<ConstrEmitItem<{
-    [K in keyof T]: (evt: K, ...args: T[K]) => void;
-}>>;
-export type ConstrClassObject = Record<string, boolean | undefined>;
-export type ConstrClass = string | (string | ConstrClass | Undefined)[] | ConstrClassObject;
-export type ConstrClassList = Record<string, ConstrClass>;
-export type ConstrClasses = {
-    main: ConstrClass;
-} & ConstrClassList;
-export type ConstrStylesItem = string | null;
-export type ConstrStyles = Record<string, ConstrStylesItem> | ConstrStyles[];
-export type ConstrOptions<COMP extends ConstrComponent, EMITS extends ConstrItem, P extends ConstrItem> = {
-    components?: COMP;
-    compMod?: ConstrComponentMod<P>;
-    emits?: ConstrEmit<EMITS>;
-    classes?: RefType<ConstrClasses>;
-    styles?: RefType<ConstrStyles>;
-};
-export type ConstrSetup<E extends Element, CLASSES extends ConstrClasses, SETUP extends ConstrItem> = {
-    name: string;
-    element: Ref<E | undefined>;
-    classes: RefType<CLASSES>;
-    styles: RefType<ConstrStyles>;
-} & SETUP;
-export type ConstrRegistration = {
-    flag?: boolean;
-    translate?: Record<string, string>;
-};
-export type ConstrBind<T> = T & Record<string, any> & {
-    key?: string;
-    class?: ConstrClass;
-    style?: ConstrStyles;
-};
-export type ConstrPropItemOptions<T = any> = {
-    type?: PropType<T>;
-    required?: boolean;
-    default?: any;
-    validator?(value: any, props: any): boolean;
-};
-export type ConstrPropItem<T = any> = ConstrPropItemOptions<T> | PropType<T>;
-export type ConstrProps<P = Record<string, any>> = {
-    [K in keyof P]: ConstrPropItem<P[K]>;
-};
-export type ConstrHrefProps = {
-    href?: string;
-};
-export type ListType = 'item' | 'space' | 'line' | 'subtitle' | 'html' | 'menu' | 'menu-group' | 'group';
-export type ListDataBasic = {
-    label?: NumberOrString;
-    value?: any;
-    search?: string;
-};
-export type ListDataItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item & {
-    parent?: string;
-    type: ListType;
-    index: string;
-    disabled?: boolean;
-}>;
-export type ListList<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item>[];
-export type ListRecord<Item extends ListDataBasic = ListDataBasic> = ListList<Item> | Record<string, any>;
-export type ListDataFullItem<Item extends ListDataBasic = ListDataBasic> = ListDataItem<Item> & {
-    focus: boolean;
-    highlight?: string;
-    selected: boolean;
-    disabled?: boolean;
-};
-export type ListDataFull<Item extends ListDataBasic = ListDataBasic> = ListDataFullItem<Item>[];
-export type ListListInputItem<Item extends ListDataBasic = ListDataBasic> = ConstrBind<Item>;
-export type ListListInput<Item extends ListDataBasic = ListDataBasic> = ListListInputItem<Item>[] | string[] | Record<string, ListListInputItem<Item>> | Record<string, string>;
-export type ListSelectedItem = NumberOrStringOrBoolean;
-export type ListSelectedList = ListSelectedItem | ListSelectedItem[];
-export type ListName = string | number | undefined;
-export type ListNames = ListName[];
-export type RefType<T> = ComputedRef<T> | Ref<T>;
-export type RefUndefined<T> = RefType<T | undefined>;
-export type RefOrNormal<T> = RefType<T> | T;
-export type RefOrNormalOrFunction<T> = RefOrNormal<T> | (() => RefOrNormal<T>);
-export type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
-export type RawSlots = {
-    [name: string]: unknown;
-    $stable?: boolean;
-};
-export type SearchListValueRef<T extends SearchItem> = RefOrNormal<SearchListValue<T>>;
-export type SearchListInput<T extends SearchItem> = SearchListValueRef<T> | (() => SearchListValueRef<T>);
-export type SearchColumnsRef<T extends SearchItem, K extends SearchColumns<T>> = RefOrNormal<K>;
-export type SearchColumnsInput<T extends SearchItem, K extends SearchColumns<T>> = SearchColumnsRef<T, K> | (() => SearchColumnsRef<T, K>);
+export declare function toBinds<R extends ItemList = ItemList>(...values: (ItemList | undefined)[]): ConstrBind<R>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxtmisha/functional",
   "private": false,
-  "version": "1.15.5",
+  "version": "1.15.7",
   "type": "module",
   "description": "A comprehensive library of utilities, base classes, and Vue 3 composables for reactive web development — API orchestration, state singletons (executeUse), storage sync, i18n, formatters, and component design. Extends @dxtmisha/functional-basic.",
   "keywords": [
@@ -70,9 +70,11 @@
     "publish-to-npm": "npm publish --access public"
   },
   "files": [
+    "ai-prompts",
     "dist",
     "ai-description.md",
     "ai-doc.md",
+    "ai-mcp.json",
     "ai-types.md",
     "CHANGELOG.md",
     "LICENSE",