@dxtmisha/functional-basic 1.10.0 → 1.10.1

package/ai-types.md

@@ -1,2 +1,2581 @@
-All these methods are in the @dxtmisha/functional-basic (v1.10.0) library.
+All these methods are in the @dxtmisha/functional-basic (v1.10.1) library.
 
+/** Class for managing HTTP requests and global API configuration. @keywords api, http, request, fetch */
+export declare class Api {
+    /** Checks if the current server environment is running on localhost. @keywords localhost, environment, check */
+    static isLocalhost(): boolean;
+    /** Returns the singleton instance of the ApiInstance class. @keywords singleton, instance */
+    static getItem(): ApiInstance;
+    /** Returns the status handler for the last executed request. @keywords status, response_status */
+    static getStatus(): ApiStatus;
+    /** Returns the response processor and handler instance. @keywords response, handler */
+    static getResponse(): ApiResponse;
+    /** Returns the API hydration handler. @keywords hydration, ssr */
+    static getHydration(): ApiHydration;
+    /** Returns a serialized HTML script tag containing client hydration data. @keywords hydration_script, ssr, script */
+    static getHydrationScript(): string;
+    /** Returns the base origin URL combined with the API path. @keywords origin, base_url, endpoint */
+    static getOrigin(): string;
+    /** Returns the full URL for a given script path. @keywords url, endpoint, path */
+    static getUrl(path: string, api?: boolean): string;
+    /** Formats and retrieves request body data for non-GET requests. @keywords body, payload, form_data */
+    static getBody(request?: ApiFetch['request'], method?: ApiMethodItem): string | FormData | undefined;
+    /** Builds a query string or appended URL for GET requests. @keywords query_string, get_params, url_query */
+    static getBodyForGet(request: ApiFetch['request'], path?: string, method?: ApiMethodItem): string;
+    /** Updates default global HTTP request headers. @keywords headers, default_headers, config */
+    static setHeaders(headers: ApiHeadersValue): void;
+    /** Sets default request parameter values. @keywords defaults, request_defaults */
+    static setRequestDefault(request: ApiDefaultValue): void;
+    /** Sets the default base script URL path. @keywords base_url, path, endpoint */
+    static setUrl(url: string): void;
+    /** Sets a hook callback to be executed before executing requests. @keywords preparation, interceptor, pre_request */
+    static setPreparation(callback: (apiFetch: ApiFetch) => Promise<void>): void;
+    /** Sets a hook callback to be executed after receiving a response. @keywords post_request, response_interceptor, end_hook */
+    static setEnd(callback: (query: Response, apiFetch: ApiFetch) => Promise<ApiPreparationEnd>): void;
+    /** Sets global request timeout in milliseconds. @keywords timeout, request_timeout */
+    static setTimeout(timeout: number): void;
+    /** Sets the base origin protocol and domain. @keywords origin, domain, host */
+    static setOrigin(origin: string): void;
+    /** Sets a custom execution wrapper around requests. @keywords wrapper, middleware, interceptor */
+    static setWrapper(wrapper: <R>(callback: () => Promise<R>, apiFetch: ApiFetch) => Promise<R>): void;
+    /** Applies multiple API configuration options at once. @keywords config, options, setup */
+    static setConfig(config?: ApiConfig): void;
+    /** Executes an HTTP request using a path string or request config. @keywords request, http, fetch */
+    static request<T>(pathRequest: string | ApiFetch): Promise<T>;
+    /** Sends a GET HTTP request. @keywords get, fetch */
+    static get<T>(request: ApiFetch): Promise<T>;
+    /** Sends a POST HTTP request. @keywords post, fetch */
+    static post<T>(request: ApiFetch): Promise<T>;
+    /** Sends a PUT HTTP request. @keywords put, fetch */
+    static put<T>(request: ApiFetch): Promise<T>;
+    /** Sends a PATCH HTTP request. @keywords patch, fetch */
+    static patch<T>(request: ApiFetch): Promise<T>;
+    /** Sends a DELETE HTTP request. @keywords delete, fetch */
+    static delete<T>(request: ApiFetch): Promise<T>;
+}
+
+/** Handles caching of API responses. @keywords api cache, response caching, cache storage */
+export declare class ApiCache {
+    /** Initializes cache storage mechanism and cleanup settings. @keywords init, cache storage, listeners */
+    static init(getListener: (key: string) => Promise<ApiCacheItem | undefined>, setListener: (key: string, value: ApiCacheItem) => Promise<boolean>, removeListener: (key: string) => Promise<boolean>, cacheStepAgeClearOld?: number): void;
+    /** Resets the cache by clearing in-memory items and resetting listeners. @keywords reset, clear cache */
+    static reset(): void;
+    /** Retrieves cached data by key. @keywords get, fetch cache, cache item */
+    static get<T>(key: string): Promise<T | undefined>;
+    /** Retrieves cached data based on fetch request configuration. @keywords get by fetch, api request cache */
+    static getByFetch<T>(fetch: ApiFetch): Promise<T | undefined>;
+    /** Stores data in the cache with optional TTL. @keywords set, save cache, store item */
+    static set<T>(key: string, value: T, age?: number): Promise<void>;
+    /** Stores data in cache using fetch request configuration. @keywords set by fetch, cache api response */
+    static setByFetch<T>(fetch: ApiFetch, value: T): Promise<void>;
+    /** Deletes an item from the cache by key. @keywords remove, delete cache, invalidate */
+    static remove(key: string): Promise<void>;
+}
+
+/** Handles and processes data returned from an API request. @keywords api, response, data handler, parser */
+export declare class ApiDataReturn<T = any> {
+    /** Initializes the API data return handler instance. @keywords constructor, api data */
+    constructor(apiFetch: ApiFetch, query: Response, end: ApiPreparationEnd, error?: ApiErrorItem | undefined);
+    /** Initializes instance by reading data from the response. @keywords init, parse, read response */
+    init(): Promise<this>;
+    /** Retrieves processed API response data. @keywords get, data, payload */
+    get(): ApiData<T>;
+    /** Retrieves processed data along with the status object. @keywords get, status, api data */
+    getAndStatus(status: ApiStatus): ApiData<T>;
+    /** Retrieves raw data received from the API. @keywords raw data, get */
+    getData(): ApiData<T> | undefined;
+}
+
+/** Class for managing default API request data. @keywords api default request */
+export declare class ApiDefault {
+    /** Checks if default request data exists. @keywords is check default */
+    is(): boolean;
+    /** Gets the default request data. @keywords get default data */
+    get(): Record<string, any> | undefined;
+    /** Merges default data into the provided request data. @keywords request merge default */
+    request(request: ApiFetch['request']): ApiFetch['request'];
+    /** Sets the default request data. @keywords set default data */
+    set(request: ApiDefaultValue): this;
+}
+
+/** Utility class for managing API error storage and resolving structured error items. @keywords api, error, error-storage, response-handling */
+export declare class ApiError {
+    /** Retrieves the singleton instance of the API error storage. @keywords storage, singleton, instance */
+    static getStorage(): ApiErrorStorage;
+    /** Adds error items to the storage matching optional URL and HTTP method criteria. @keywords add, register, error-item, filter */
+    static add(item: Partial<ApiErrorStorageItem> | Partial<ApiErrorStorageItem>[], url?: string | RegExp, method?: ApiMethodItem): void;
+    /** Creates an ApiErrorItem by matching the response against stored error criteria. @keywords get-item, match, parse-error, response */
+    static getItem(method: ApiMethodItem, response: Response): Promise<ApiErrorItem>;
+}
+
+/** Manages and extracts error codes, messages, and status from API error responses. @keywords api error response handler parser */
+export declare class ApiErrorItem {
+    /** Initializes an ApiErrorItem instance. @keywords constructor init */
+    constructor(method: ApiMethodItem, response: Response, error: ApiErrorStorageItem);
+    /** Retrieves the HTTP method used for the request. @keywords method http */
+    getMethod(): ApiMethodItem;
+    /** Retrieves the raw Fetch response object. @keywords response fetch raw */
+    getResponse(): Response;
+    /** Retrieves the matched error storage item. @keywords error item storage */
+    getError(): ApiErrorStorageItem;
+    /** Retrieves the error code from storage or the response body. @keywords code error */
+    getCode(): string | undefined;
+    /** Retrieves the error message from storage, response body, or status text. @keywords message error */
+    getMessage(): string | undefined;
+    /** Retrieves the HTTP status code of the response. @keywords status http code */
+    getStatus(): number;
+}
+
+/** Centralized storage and matcher for identifying API error states based on response criteria. @keywords api error storage matcher status handler */
+export declare class ApiErrorStorage {
+    /** Finds a matching error item in storage by analyzing the API method and response. @keywords find match error response */
+    find(method: ApiMethodItem, response: Response): Promise<ApiErrorStorageItem>;
+    /** Adds one or more API error items or patterns to the internal storage. @keywords add register error rule pattern */
+    add(item: Partial<ApiErrorStorageItem> | Partial<ApiErrorStorageItem>[], url?: string | RegExp, method?: ApiMethodItem): this;
+}
+
+/** Class for managing and resolving HTTP request headers. @keywords http headers, request headers, api headers */
+export declare class ApiHeaders {
+    /** Resolves and merges HTTP request headers with optional Content-Type. @keywords get headers, merge headers, content-type */
+    get(value?: Record<string, string> | null, type?: string | undefined | null): Record<string, string> | undefined;
+    /** Resolves headers tailored to the specific request configuration. @keywords headers by request, request headers */
+    getByRequest(request: ApiFetch['request'], value?: Record<string, string> | null, type?: string): Record<string, string> | undefined;
+    /** Sets the default headers. @keywords default headers, set headers */
+    set(headers: ApiHeadersValue): this;
+}
+
+/** Collects API data during SSR for client-side hydration. @keywords ssr hydration api data transfer */
+export declare class ApiHydration {
+    /** Initializes the API response with hydration payload. @keywords ssr init response hydration */
+    initResponse(response: ApiResponse): void;
+    /** Saves an API response for client-side hydration. @keywords ssr cache response hydration state */
+    toClient<T>(apiFetch: ApiFetch, response: T): void;
+    /** Serializes hydration data into a string for client injection. @keywords serialize hydration string ssr */
+    toString(): string;
+}
+
+/** Options for configuring an ApiInstance. @keywords api, options, config */
+export type ApiInstanceOptions = {
+    headersClass?: typeof ApiHeaders;
+    requestDefaultClass?: typeof ApiDefault;
+    statusClass?: typeof ApiStatus;
+    responseClass?: typeof ApiResponse;
+    preparationClass?: typeof ApiPreparation;
+    loadingClass?: LoadingInstance;
+    errorCenterClass?: ErrorCenterInstance;
+    hydrationClass?: typeof ApiHydration;
+    wrapper?: <R>(callback: () => Promise<R>, apiFetch: ApiFetch) => Promise<R>;
+};
+/** Core class for managing HTTP requests using the Fetch API. @keywords api, fetch, http, client */
+export declare class ApiInstance {
+    /** Creates an ApiInstance with an optional base URL and configuration options. @keywords constructor, init */
+    constructor(url?: string, options?: ApiInstanceOptions);
+    /** Checks if the server is running on localhost. @keywords localhost, environment, host */
+    isLocalhost(): boolean;
+    /** Returns the status handler of the last request. @keywords status, state */
+    getStatus(): ApiStatus;
+    /** Gets the response handler instance. @keywords response, handler */
+    getResponse(): ApiResponse;
+    /** Gets the hydration handler instance. @keywords hydration, ssr */
+    getHydration(): ApiHydration;
+    /** Gets the base origin URL combined with the API path. @keywords origin, url, base */
+    getOrigin(): string;
+    /** Gets the full URL path for a request script. @keywords url, endpoint, path */
+    getUrl(path: string, api?: boolean): string;
+    /** Serializes request data into a body payload or FormData. @keywords body, payload, formdata */
+    getBody(request?: ApiFetch['request'], method?: ApiMethod): string | FormData | undefined;
+    /** Generates a formatted query string for GET requests. @keywords query, search_params, url_params */
+    getBodyForGet(request: ApiFetch['request'], path?: string, method?: ApiMethod): string;
+    /** Returns a script tag string containing client hydration data. @keywords hydration, script, ssr */
+    getHydrationScript(): string;
+    /** Updates default headers applied to requests. @keywords headers, config */
+    setHeaders(headers: ApiHeadersValue): this;
+    /** Updates default request configuration parameters. @keywords default, config, options */
+    setRequestDefault(request: ApiDefaultValue): this;
+    /** Sets the base script path. @keywords url, endpoint, base */
+    setUrl(url: string): this;
+    /** Sets an interceptor callback to run before request execution. @keywords interceptor, preparation, middleware */
+    setPreparation(callback: (apiFetch: ApiFetch) => Promise<void>): this;
+    /** Sets an interceptor callback to run after request completion. @keywords interceptor, response, callback */
+    setEnd(callback: (query: Response, apiFetch: ApiFetch) => Promise<ApiPreparationEnd>): this;
+    /** Sets the default request timeout in milliseconds. @keywords timeout, delay */
+    setTimeout(timeout: number): this;
+    /** Sets the base origin protocol and domain. @keywords origin, domain, host */
+    setOrigin(origin: string): this;
+    /** Sets a wrapper function wrapping request execution. @keywords wrapper, middleware */
+    setWrapper(wrapper: <R>(callback: () => Promise<R>, apiFetch: ApiFetch) => Promise<R>): this;
+    /** Executes an HTTP request with the given path or configuration. @keywords request, fetch, http */
+    request<T>(pathRequest: string | ApiFetch): Promise<T>;
+    /** Sends an HTTP GET request. @keywords get, fetch, query */
+    get<T>(request: ApiFetch): Promise<T>;
+    /** Sends an HTTP POST request. @keywords post, submit, mutation */
+    post<T>(request: ApiFetch): Promise<T>;
+    /** Sends an HTTP PUT request. @keywords put, update */
+    put<T>(request: ApiFetch): Promise<T>;
+    /** Sends an HTTP PATCH request. @keywords patch, update */
+    patch<T>(request: ApiFetch): Promise<T>;
+    /** Sends an HTTP DELETE request. @keywords delete, remove */
+    delete<T>(request: ApiFetch): Promise<T>;
+}
+
+/** Handles pre-request preparation and post-request analysis hooks. @keywords api preparation, interceptor, request lifecycle */
+export declare class ApiPreparation {
+    /** Executes pre-request preparation logic if active. @keywords pre-request, prepare */
+    make(active: boolean, apiFetch: ApiFetch): Promise<void>;
+    /** Analyzes and processes response data after request execution. @keywords post-request, response interceptor */
+    makeEnd(active: boolean, query: Response, apiFetch: ApiFetch): Promise<ApiPreparationEnd>;
+    /** Registers the pre-request callback hook. @keywords pre-request hook, interceptor */
+    set(callback: (apiFetch: ApiFetch) => Promise<void>): this;
+    /** Registers the post-request callback hook. @keywords post-request hook, response handler */
+    setEnd(callback: (query: Response, apiFetch: ApiFetch) => Promise<ApiPreparationEnd>): this;
+}
+
+/** Manages cached API responses, mocking, and request emulation. @keywords api response cache emulator mock */
+export declare class ApiResponse {
+    /** Initializes API response manager with default request configuration. @keywords constructor init */
+    constructor(requestDefault: ApiDefault);
+    /** Retrieves a matching cached API response if available. @keywords get cache lookup */
+    get(path: string | undefined, method: ApiMethod, request?: ApiFetch['request'], devMode?: boolean): ApiResponseItem | undefined;
+    /** Returns all locally cached API response items. @keywords list items cache */
+    getList(): (ApiResponseItem & Record<string, any>)[];
+    /** Adds one or multiple cached API response entries. @keywords add register cache */
+    add(response: ApiResponseItem | ApiResponseItem[]): this;
+    /** Enables or disables developer mode. @keywords dev mode toggle */
+    setDevMode(devMode: boolean): this;
+    /** Asynchronously executes mock or emulated API response handler. @keywords emulator mock async request */
+    emulator<T>(apiFetch: ApiFetch): Promise<T | undefined>;
+    /** Synchronously executes mock or emulated API response handler. @keywords emulator mock sync request */
+    emulatorAsync<T>(apiFetch: ApiFetch): T | undefined;
+}
+
+/** Class for managing API request status. @keywords api, status, request, response */
+export declare class ApiStatus {
+    /** Returns the last status item data. @keywords status item, state */
+    get(): ApiStatusItem | undefined;
+    /** Returns the HTTP execution status code. @keywords http status, status code */
+    getStatus(): number | undefined;
+    /** Returns the execution status text. @keywords status text, http message */
+    getStatusText(): string | undefined;
+    /** Returns the last status type. @keywords status type, state */
+    getStatusType(): ApiStatusType | undefined;
+    /** Returns the execution status code from the response. @keywords code, response code */
+    getCode(): string | undefined;
+    /** Returns the script execution error message. @keywords error, failure */
+    getError(): string | undefined;
+    /** Returns the data of the last request response. @keywords response, payload, data */
+    getResponse<T>(): T | undefined;
+    /** Returns messages from the last request. @keywords message, response message */
+    getMessage(): string;
+    /** Sets the status item data. @keywords set status, state */
+    set(data: ApiStatusItem): this;
+    /** Sets the status code and optional status text. @keywords set status, http code */
+    setStatus(status?: number, statusText?: string): this;
+    /** Sets the error message. @keywords set error, failure */
+    setError(error?: string): this;
+    /** Sets last response data and auto-extracts status or message. @keywords set response, payload */
+    setLastResponse(response?: any): this;
+    /** Sets the last status type. @keywords set status, status type */
+    setLastStatus(status?: ApiStatusType): this;
+    /** Sets the last execution status code. @keywords set code, status code */
+    setLastCode(code?: string): this;
+    /** Sets messages from the last request. @keywords set message */
+    setLastMessage(message?: string): this;
+}
+
+/** Manages cross-context messaging using the BroadcastChannel API. @keywords broadcast channel, messaging, cross-tab, communication */
+export declare class BroadcastMessage<Message = any> {
+    /** Initializes the broadcast channel with handlers. @keywords broadcast, channel, init */
+    constructor(name: string, callback?: ((event: MessageEvent<Message>) => void) | undefined, callbackError?: ((event: MessageEvent<Message>) => void) | undefined, errorCenter?: ErrorCenterInstance);
+    /** Gets the underlying BroadcastChannel instance if available. @keywords broadcast channel, instance */
+    getChannel(): BroadcastChannel | undefined;
+    /** Sends a message through the broadcast channel. @keywords post message, broadcast, send */
+    post(message: Message): this;
+    /** Sets the message reception callback handler. @keywords onmessage, listener, callback */
+    setCallback(callback: (event: MessageEvent<Message>) => void): this;
+    /** Sets the message error callback handler. @keywords onmessageerror, error handler */
+    setCallbackError(callbackError: (event: MessageEvent<Message>) => void): this;
+    /** Closes the broadcast channel and stops listening for messages. @keywords destroy, close, cleanup */
+    destroy(): this;
+}
+
+/** In-memory key-value cache with dependency-based invalidation. @keywords cache, memoize, storage, in-memory */
+export declare class Cache {
+    /** Retrieves or computes a cached value by key with optional invalidation dependencies. @keywords cache get, memoize, compute */
+    get<T>(name: string, callback: () => T, comparison?: any[]): T;
+    /** Asynchronously retrieves or computes a cached value by key with optional invalidation dependencies. @keywords async cache, memoize promise, async storage */
+    getAsync<T>(name: string, callback: () => T, comparison?: any[]): Promise<T>;
+}
+
+/** Manages a single cached value with dependency tracking for invalidation. @keywords cache memoize dependency invalidation */
+export declare class CacheItem<T> {
+    /** Creates a CacheItem with a value computation callback. @keywords cache construct */
+    constructor(callback: () => T);
+    /** Returns cached value, recomputing if dependency array changes. @keywords get cache memoize */
+    getCache(comparison: any[]): T;
+    /** Returns previous cached value before last recalculation. @keywords previous cache history */
+    getCacheOld(): T | undefined;
+    /** Asynchronously returns cached value, recomputing if dependency array changes. @keywords async cache memoize */
+    getCacheAsync(comparison: any[]): Promise<T>;
+}
+
+/** Static cache utility using ServerStorage for persistent application-wide caching. @warning Obsolete. @keywords cache static server storage memoize */
+export declare class CacheStatic {
+    /** Gets a cached value by key, or computes and caches the result using the callback. @keywords cache memoize get */
+    static get<T>(name: string, callback: () => T, comparison?: any[]): T;
+    /** Asynchronously gets a cached value by key, or computes and caches the result using the callback. @keywords async cache memoize getAsync */
+    static getAsync<T>(name: string, callback: () => T, comparison?: any[]): Promise<T>;
+}
+
+/** Cookie management utility. @keywords cookie, storage, browser */
+export declare class Cookie<T> {
+    /** Gets a Cookie instance by name. @keywords cookie, getInstance, singleton */
+    static getInstance<T>(name: string): Cookie<T>;
+    /** Creates a new Cookie instance. @keywords cookie, constructor */
+    constructor(name: string);
+    /** Gets cookie data or initializes with default value if absent. @keywords cookie, get, read */
+    get(defaultValue?: T | string | (() => (T | string)), options?: CookieOptions): string | T | undefined;
+    /** Updates the cookie value. @keywords cookie, set, write */
+    set(value?: T | string | (() => (T | string)), options?: CookieOptions): void;
+    /** Deletes the cookie. @keywords cookie, remove, delete */
+    remove(): void;
+}
+
+/** Manages cookie access block status. @keywords cookie, block, access */
+export declare class CookieBlock {
+    /** Returns a request-isolated CookieBlockInstance. @keywords cookie, instance, isolated */
+    static getItem(): CookieBlockInstance;
+    /** Retrieves the current cookie block status. @keywords cookie, block, status, get */
+    static get(): boolean;
+    /** Sets the cookie block status. @keywords cookie, block, status, set */
+    static set(value: boolean): void;
+}
+
+/** Manages cookie access blocking status. @keywords cookie block status access */
+export declare class CookieBlockInstance {
+    /** Gets the current cookie block status. @keywords get cookie block status */
+    get(): boolean;
+    /** Sets the cookie block status. @keywords set cookie block status */
+    set(value: boolean): void;
+}
+
+export type CookieSameSite = 'strict' | 'lax';
+
+/** Options for setting and configuring cookies. @keywords cookie, options, samesite, secure */
+export type CookieOptions = {
+    age?: number;
+    sameSite?: CookieSameSite;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    partitioned?: boolean;
+    arguments?: string[] | Record<string, string | number | boolean>;
+};
+
+/** Manages cookie storage with custom listeners across DOM and SSR environments. @keywords cookie, storage, ssr, browser, persistence */
+export declare class CookieStorage {
+    /** Initializes cookie storage with custom getter and setter listeners. @keywords init, listener, ssr */
+    static init(getListener?: (key: string) => any | undefined, getListenerRaw?: () => string, setListener?: (key: string, value: any, cookie: string, options?: CookieOptions) => void): void;
+    /** Resets the storage by clearing all in-memory items and resetting listeners. @keywords reset, clear */
+    static reset(): void;
+    /** Retrieves a typed cookie value from storage or returns a default fallback. @keywords get, read, retrieve */
+    static get<T>(name: string, defaultValue?: T | (() => T)): T | undefined;
+    /** Saves a value to cookie storage with configurable options. @keywords set, write, store */
+    static set<T>(name: string, value: T | (() => T), options?: CookieOptions): T;
+    /** Removes a cookie by name from storage. @keywords remove, delete, clear */
+    static remove(name: string): void;
+    /** Synchronizes and updates in-memory storage cache from current cookies. @keywords update, sync, refresh */
+    static update(): void;
+}
+
+/** Storage wrapper for localStorage and sessionStorage with prefix, TTL expiration, and SSR isolation. @keywords storage, localStorage, sessionStorage, cache, ssr */
+export declare class DataStorage<T> {
+    /** Sets global key prefix for storage items. @keywords prefix, key, storage */
+    static setPrefix(newPrefix: string): void;
+    /** Initializes storage instance for a named key. @keywords storage, constructor, session */
+    constructor(name: string, isSession?: boolean, errorCenter?: ErrorCenterInstance);
+    /** Retrieves stored item value or fallback default value with optional cache expiration. @keywords get, retrieve, cache, ttl */
+    get(defaultValue?: T | (() => T), cache?: number): T | undefined;
+    /** Sets or updates stored item value. @keywords set, save, update, store */
+    set(value?: T | (() => T)): T | undefined;
+    /** Removes item from storage. @keywords remove, delete, clear */
+    remove(): this;
+    /** Synchronizes data from underlying storage. @keywords update, sync, refresh */
+    update(): this;
+}
+
+/**
+ * Utility class for date manipulation, calculation, and localization.
+ * @remarks Creating a `Datetime` instance without a specific date (using the current time) for SSR rendering may lead to hydration mismatches due to server/client timezone differences.
+ * @keywords datetime date time calendar localization
+ */
+export declare class Datetime {
+    /** Creates a Datetime instance. @keywords constructor datetime */
+    constructor(date?: NumberOrStringOrDate, type?: GeoDate, code?: string);
+    /** Returns the GeoIntl formatting instance. @keywords intl format */
+    getIntl(): GeoIntl;
+    /** Returns the underlying native Date object. @keywords date native */
+    getDate(): Date;
+    /** Returns the configured date display format type. @keywords type format */
+    getType(): GeoDate;
+    /** Returns the hour format type. @keywords hours format */
+    getHoursType(): GeoHours;
+    /** Returns whether 24-hour time format is enabled. @keywords 24-hour format */
+    getHour24(): boolean;
+    /** Returns the time zone offset in minutes relative to UTC. @keywords timezone offset utc */
+    getTimeZoneOffset(): number;
+    /** Returns the time zone string. @keywords timezone */
+    getTimeZone(style?: GeoTimeZoneStyle): string;
+    /** Returns the code of the first day of the week for the current locale. @keywords first day weekday */
+    getFirstDayCode(): GeoFirstDay;
+    /** Returns the four-digit year according to local time. @keywords year local */
+    getYear(): number;
+    /** Returns the 1-based month index (1-12) according to local time. @keywords month local */
+    getMonth(): number;
+    /** Returns the day of the month (1-31) according to local time. @keywords day month local */
+    getDay(): number;
+    /** Returns the hour (0-23) according to local time. @keywords hour local */
+    getHour(): number;
+    /** Returns the minute (0-59) according to local time. @keywords minute local */
+    getMinute(): number;
+    /** Returns the second (0-59) according to local time. @keywords second local */
+    getSecond(): number;
+    /** Returns the total number of days (28-31) in the current month. @keywords days in month max day */
+    getMaxDay(): number;
+    /** Formats the date and time according to the current locale. @keywords locale format intl */
+    locale(type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions): string;
+    /** Formats the year according to the current locale. @keywords locale year format */
+    localeYear(style?: Intl.DateTimeFormatOptions['year']): string;
+    /** Formats the month according to the current locale. @keywords locale month format */
+    localeMonth(style?: Intl.DateTimeFormatOptions['month']): string;
+    /** Formats the day according to the current locale. @keywords locale day format */
+    localeDay(style?: Intl.DateTimeFormatOptions['day']): string;
+    /** Formats the hour according to the current locale. @keywords locale hour format */
+    localeHour(style?: Intl.DateTimeFormatOptions['hour']): string;
+    /** Formats the minute according to the current locale. @keywords locale minute format */
+    localeMinute(style?: Intl.DateTimeFormatOptions['minute']): string;
+    /** Formats the second according to the current locale. @keywords locale second format */
+    localeSecond(style?: Intl.DateTimeFormatOptions['second']): string;
+    /** Returns the date in standard ISO-like format. @keywords standard format iso */
+    standard(timeZone?: boolean): string;
+    /** Sets the date value from a number, string, or Date instance. @keywords set date */
+    setDate(value: NumberOrStringOrDate): this;
+    /** Sets the date display format type. @keywords set format type */
+    setType(value: GeoDate): this;
+    /** Sets whether to use 24-hour time format. @keywords set 24-hour format */
+    setHour24(value: boolean): this;
+    /** Sets the country and language locale code. @keywords set locale code */
+    setCode(code: string): this;
+    /** Registers a callback invoked when the date value is updated. @keywords watch listener callback */
+    setWatch(watch: (date: Date, type: GeoDate, hour24: boolean) => void): this;
+    /** Sets the full year according to local time. @keywords set year */
+    setYear(value: number): this;
+    /** Sets the 1-based month (1-12) according to local time. @keywords set month */
+    setMonth(value: number): this;
+    /** Sets the day of the month (1-31) according to local time. @keywords set day */
+    setDay(value: number): this;
+    /** Sets the hour (0-23) according to local time. @keywords set hour */
+    setHour(value: number): this;
+    /** Sets the minute (0-59) according to local time. @keywords set minute */
+    setMinute(value: number): this;
+    /** Sets the second (0-59) according to local time. @keywords set second */
+    setSecond(value: number): this;
+    /** Shifts the date by the specified number of years. @keywords move shift year */
+    moveByYear(value: number): this;
+    /** Shifts the date by the specified number of months. @keywords move shift month */
+    moveByMonth(value: number): this;
+    /** Shifts the date by the specified number of days. @keywords move shift day */
+    moveByDay(value: number): this;
+    /** Shifts the date by the specified number of hours. @keywords move shift hour */
+    moveByHour(value: number): this;
+    /** Shifts the date by the specified number of minutes. @keywords move shift minute */
+    moveByMinute(value: number): this;
+    /** Shifts the date by the specified number of seconds. @keywords move shift second */
+    moveBySecond(value: number): this;
+    /** Sets the month to January. @keywords january first month */
+    moveMonthFirst(): this;
+    /** Sets the month to December. @keywords december last month */
+    moveMonthLast(): this;
+    /** Advances the date to the first day of the next month. @keywords next month */
+    moveMonthNext(): this;
+    /** Moves the date to the first day of the previous month. @keywords previous month */
+    moveMonthPrevious(): this;
+    /** Moves the date to the first day of the current week. @keywords first weekday week start */
+    moveWeekdayFirst(): this;
+    /** Moves the date to the last day of the current week. @keywords last weekday week end */
+    moveWeekdayLast(): this;
+    /** Moves the date to the first day of the month's first week. @keywords month first weekday */
+    moveWeekdayFirstByMonth(): this;
+    /** Moves the date to the first day of the next month's first full week. @keywords month last weekday */
+    moveWeekdayLastByMonth(): this;
+    /** Advances the date by one week. @keywords next week */
+    moveWeekdayNext(): this;
+    /** Moves the date back by one week. @keywords previous week */
+    moveWeekdayPrevious(): this;
+    /** Moves the date to the first day of the current month. @keywords first day month start */
+    moveDayFirst(): this;
+    /** Moves the date to the last day of the current month. @keywords last day month end */
+    moveDayLast(): this;
+    /** Advances the date to the next day. @keywords next day tomorrow */
+    moveDayNext(): this;
+    /** Moves the date to the previous day. @keywords previous day yesterday */
+    moveDayPrevious(): this;
+    /** Creates a clone of the underlying native Date object. @keywords clone date */
+    clone(): Date;
+    /** Creates a clone of this Datetime instance. @keywords clone datetime */
+    cloneClass(): Datetime;
+    /** Clones the Datetime instance with month set to January. @keywords clone january */
+    cloneMonthFirst(): Datetime;
+    /** Clones the Datetime instance with month set to December. @keywords clone december */
+    cloneMonthLast(): Datetime;
+    /** Clones the Datetime instance and advances it by one month. @keywords clone next month */
+    cloneMonthNext(): Datetime;
+    /** Clones the Datetime instance and moves it back by one month. @keywords clone previous month */
+    cloneMonthPrevious(): Datetime;
+    /** Clones the Datetime instance set to the first day of the current week. @keywords clone week start */
+    cloneWeekdayFirst(): Datetime;
+    /** Clones the Datetime instance set to the last day of the current week. @keywords clone week end */
+    cloneWeekdayLast(): Datetime;
+    /** Clones the Datetime instance set to the first day of the month's first week. @keywords clone month week start */
+    cloneWeekdayFirstByMonth(): Datetime;
+    /** Clones the Datetime instance set to the last day of the month's last week. @keywords clone month week end */
+    cloneWeekdayLastByMonth(): Datetime;
+    /** Clones the Datetime instance advanced by one week. @keywords clone next week */
+    cloneWeekdayNext(): Datetime;
+    /** Clones the Datetime instance moved back by one week. @keywords clone previous week */
+    cloneWeekdayPrevious(): Datetime;
+    /** Clones the Datetime instance set to the first day of the month. @keywords clone month start */
+    cloneDayFirst(): Datetime;
+    /** Clones the Datetime instance set to the last day of the month. @keywords clone month end */
+    cloneDayLast(): Datetime;
+    /** Clones the Datetime instance advanced by one day. @keywords clone next day */
+    cloneDayNext(): Datetime;
+    /** Clones the Datetime instance moved back by one day. @keywords clone previous day */
+    cloneDayPrevious(): Datetime;
+}
+
+/** Error management and handling center. @keywords error, handler, registry, storage */
+export declare class ErrorCenter {
+    /** Returns request-isolated ErrorCenter instance. @keywords instance, singleton, context */
+    static getItem(): ErrorCenterInstance;
+    /** Checks if an error cause exists by code and optional group. @keywords exists, check, has */
+    static has(code: string, group?: string): boolean;
+    /** Retrieves an error cause item by code and group. @keywords get, find, cause */
+    static get(code: string, group?: string): ErrorCenterCauseItem | undefined;
+    /** Registers an error cause. @keywords add, register, cause */
+    static add(cause: ErrorCenterCauseItem): void;
+    /** Registers multiple error causes. @keywords addList, batch, causes */
+    static addList(causes: ErrorCenterCauseList): void;
+    /** Registers an error handler for a specific group. @keywords handler, group, listen */
+    static addHandler(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): void;
+    /** Registers multiple error handlers. @keywords handlers, list, batch */
+    static addHandlerList(handlers: ErrorCenterHandlerList): void;
+    /** Registers a global callback executed on any error. @keywords callback, global, hook */
+    static addCallback(callback: ErrorCenterHandlerCallback): void;
+    /** Configures console output logging or filter. @keywords console, log, filter */
+    static setIsConsole(isConsole: ErrorCenterHandlerIsConsole): void;
+    /** Triggers error handling workflow for an error cause. @keywords trigger, dispatch, emit */
+    static on(cause: ErrorCenterCauseItem): void;
+}
+
+/** Manages and triggers error handlers by group or globally. @keywords error center, handler, error handling */
+export declare class ErrorCenterHandler {
+    /** Initializes the error center handler manager. @keywords constructor, init */
+    constructor(handlers?: ErrorCenterHandlerList, isConsole?: ErrorCenterHandlerIsConsole);
+    /** Checks if handlers exist for a specific error group. @keywords has, error group, check */
+    has(group: ErrorCenterGroup): boolean;
+    /** Retrieves handlers associated with an error group. @keywords get, handler item */
+    get(group: ErrorCenterGroup): ErrorCenterHandlerItem | undefined;
+    /** Registers an error handler callback for a specific group. @keywords add, register, error handler */
+    add(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this;
+    /** Registers a list of group-based error handlers. @keywords add list, batch register */
+    addList(handlers: ErrorCenterHandlerList): this;
+    /** Registers a global callback executed on any error. @keywords add callback, global handler */
+    addCallback(callback: ErrorCenterHandlerCallback): this;
+    /** Sets the console logging flag or filter predicate. @keywords console output, logging, filter */
+    setIsConsole(isConsole: ErrorCenterHandlerIsConsole): this;
+    /** Dispatches error handlers matching the cause and handles console logging. @keywords dispatch, trigger, handle error */
+    on(cause: ErrorCenterCauseItem): this;
+}
+
+/** Manages error storage and handling within an instance. @keywords error center, error manager, error storage */
+export declare class ErrorCenterInstance {
+    /** Initializes the error center instance with optional causes and handler. @keywords constructor, error center */
+    constructor(causes?: ErrorCenterCauseList, handler?: ErrorCenterHandler);
+    /** Checks if an error cause exists by code and optional group. @keywords error check, has cause */
+    has(code: string, group?: string): boolean;
+    /** Retrieves an error cause item by code and optional group. @keywords get error, find cause */
+    get(code: string, group?: string): ErrorCenterCauseItem | undefined;
+    /** Adds an error cause item to storage. @keywords add error, register cause */
+    add(cause: ErrorCenterCauseItem): this;
+    /** Adds a list of error causes to storage. @keywords add error list, batch causes */
+    addList(causes: ErrorCenterCauseList): this;
+    /** Registers an error handler callback for a specific group. @keywords add handler, register callback */
+    addHandler(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this;
+    /** Registers multiple error handlers from a list. @keywords add handlers, batch handlers */
+    addHandlerList(handlers: ErrorCenterHandlerList): this;
+    /** Registers a global callback executed on any error. @keywords error callback, global listener */
+    addCallback(callback: ErrorCenterHandlerCallback): this;
+    /** Sets console logging behavior or filter function. @keywords console logging, debug output */
+    setIsConsole(isConsole: ErrorCenterHandlerIsConsole): this;
+    /** Triggers error handling for an error cause item. @keywords trigger error, dispatch cause */
+    on(cause: ErrorCenterCauseItem): this;
+}
+
+/**
+ * Advanced wrapper for managing DOM event listeners with lifecycle control, safety checks, and optimizations.
+ * @keywords event listener, dom events, resize observer, scroll sync, event item
+ */
+export declare class EventItem<E extends ElementOrWindow, O extends Event, D extends Record<string, any> = Record<string, any>> {
+    /** Creates an EventItem instance. @keywords event item, constructor */
+    constructor(elementSelector?: ElementOrString<E>, type?: string | string[], listener?: EventListenerDetail<O, D> | undefined, options?: EventOptions, detail?: D | undefined);
+    /** Checks whether event listening is active. @keywords is active, listening status */
+    isActive(): boolean;
+    /** Returns the target DOM element or window. @keywords get element, target */
+    getElement(): E | undefined;
+    /** Sets the target DOM element or selector for event listening. @keywords set element, target */
+    setElement(elementSelector?: ElementOrString<E>): this;
+    /** Sets the control element for DOM safety checks. @keywords element control, dom safety */
+    setElementControl<EC extends HTMLElement>(elementSelector?: ElementOrString<EC>): this;
+    /** Sets the handled event type or types. @keywords set type, event type */
+    setType(type: string | string[]): this;
+    /** Sets the event handler listener function. @keywords set listener, handler */
+    setListener(listener: EventListenerDetail<O, D>): this;
+    /** Sets the event listener options. @keywords set options, event options */
+    setOptions(options?: EventOptions): this;
+    /** Sets custom detail data passed to the listener or dispatch. @keywords set detail, custom data */
+    setDetail(detail?: D): this;
+    /** Dispatches a CustomEvent on the target element with optional detail data. @keywords dispatch, trigger event, custom event */
+    dispatch(detail?: D | undefined): this;
+    /** Starts listening to configured events. @keywords start, add event listener, attach */
+    start(): this;
+    /** Stops listening to events. @keywords stop, remove event listener, detach */
+    stop(): this;
+    /** Toggles event listening state based on the provided active flag. @keywords toggle, enable, disable */
+    toggle(activity: boolean): this;
+    /** Restarts active event listeners. @keywords reset, restart listener, reload */
+    reset(): this;
+}
+
+/** Formats a list or single data item based on provided column formatting options. @keywords format, list, data, options */
+export declare class Formatters<Options extends FormattersOptionsList = FormattersOptionsList, List extends FormattersListProp = FormattersListProp, Item extends FormattersItemProp<List> = FormattersItemProp<List>> {
+    /** Initializes the formatters instance with options and optional list data. @keywords constructor, init, setup */
+    constructor(options: Options, list?: List | undefined);
+    /** Checks if the list data is set. @keywords check, is set, exists */
+    is(): boolean;
+    /** Type guard checking if the list data is an array. @keywords isArray, type guard */
+    isArray(): this is this & {
+        list: FormattersList<Item>;
+    };
+    /** Returns the number of records in the list. @keywords count, length, size */
+    length(): number;
+    /** Returns the current list of items as an array. @keywords getList, items, array */
+    getList(): FormattersList<Item>;
+    /** Returns the current formatting options configuration. @keywords getOptions, configuration, settings */
+    getOptions(): Options;
+    /** Sets the list of data to be formatted. @keywords setList, update, list */
+    setList(list?: List): this;
+    /** Formats the entire list or single item, appending formatted values with 'Format' suffixes. @keywords to, format, transform */
+    to(): FormattersReturn<List, Options>;
+}
+
+/** Static utility class for managing geographical data, locale, country, and time zone. @keywords geo, locale, country, timezone */
+export declare class Geo {
+    /** Returns a request-isolated instance of GeoInstance. @keywords geo, instance, isolate */
+    static getObject(): GeoInstance;
+    /** Returns information about the current country and language. @keywords current, geo, locale */
+    static get(): GeoItemFull;
+    /** Returns the 2-letter code of the current country. @keywords country, code, iso */
+    static getCountry(): string;
+    /** Returns the 2-letter code of the current language. @keywords language, code, iso */
+    static getLanguage(): string;
+    /** Returns the combined locale string in standard format (e.g., 'en-US'). @keywords locale, standard, format */
+    static getStandard(): string;
+    /** Returns the code for the first day of the week for the current locale. @keywords first-day, week, calendar */
+    static getFirstDay(): string;
+    /** Returns the current location string. @keywords location, current */
+    static getLocation(): string;
+    /** Returns the country code extracted from the location string. @keywords location, country, code */
+    static getLocationCountry(): string;
+    /** Returns the language code extracted from the location string. @keywords location, language, code */
+    static getLocationLanguage(): string;
+    /** Returns fully processed geo data updated with the current language. @keywords geo, item, processed */
+    static getItem(): GeoItemFull;
+    /** Returns the complete list of available countries and regions. @keywords list, countries, regions */
+    static getList(): GeoItem[];
+    /** Returns geo data by country or language code from the global database. @keywords search, code, lookup */
+    static getByCode(code?: string): GeoItemFull;
+    /** Returns exact geo data by searching for full locale match (e.g., 'en-US'). @keywords full, locale, lookup */
+    static getByCodeFull(code: string): GeoItem | undefined;
+    /** Returns geo data for a specific country by its code. @keywords country, lookup */
+    static getByCountry(country: string): GeoItem | undefined;
+    /** Returns geo data for a specific language by its code. @keywords language, lookup */
+    static getByLanguage(language: string): GeoItem | undefined;
+    /** Returns the time zone offset in minutes for the current context. @keywords timezone, offset, minutes */
+    static getTimezone(): number;
+    /** Returns the formatted time zone string (e.g., '+00:00') for the current context. @keywords timezone, format, offset */
+    static getTimezoneFormat(): string;
+    /** Finds or determines the geo data for a given code (alias for getByCode). @keywords find, search, geo */
+    static find(code: string): GeoItemFull;
+    /** Returns a standard concatenated string for a geo item (e.g., 'en-US'). @keywords standard, format, locale */
+    static toStandard(item: GeoItem): string;
+    /** Sets the current geographical location and updates instance state. @keywords set, location, state */
+    static set(code: string, save?: boolean): void;
+    /** Sets a custom time zone offset in minutes for the current context. @keywords set, timezone, offset */
+    static setTimezone(timezone: number): void;
+    /** Sets the default value or resolver function for the country code. @keywords default, country, fallback */
+    static setValueDefault(code?: string | (() => string)): void;
+    /** Adds or updates country geo data and merges with existing entries. @keywords add, country, merge */
+    static add(country: string, item: Partial<GeoItem>): GeoInstance;
+    /** Adds or updates multiple countries in the geo list. @keywords add, batch, list */
+    static addList(list: Record<string, Partial<GeoItem>>): GeoInstance;
+}
+
+export declare const GEO_FLAG_ICON_NAME = "f";
+/** Handles flags, country names, languages, and geographic metadata. @keywords geo, flag, country, language, locale */
+export declare class GeoFlag {
+    /** Mapping of country codes to flag icon names. @keywords flags, country codes, icon map */
+    static flags: Record<string, string>;
+    /** Initializes GeoFlag with an optional country/language code. @keywords geo flag, constructor, locale */
+    constructor(code?: string);
+    /** Retrieves country information and flag data by country code. @keywords country, flag, metadata */
+    get(code?: string): GeoFlagItem | undefined;
+    /** Retrieves language information and associated flag by code. @keywords language, flag, metadata */
+    getLanguage(code?: string): GeoFlagItem | undefined;
+    /** Returns the active country code. @keywords get code, country code, locale */
+    getCode(): string;
+    /** Returns the flag icon identifier for a given country code. @keywords flag icon, icon id */
+    getFlag(code?: string): string | undefined;
+    /** Retrieves a list of countries for specified codes or all available countries. @keywords country list, countries */
+    getList(codes?: string[], sort?: boolean): GeoFlagItem[];
+    /** Retrieves a list of languages for specified codes or all available languages. @keywords language list, languages */
+    getListLanguage(codes?: string[], sort?: boolean): GeoFlagItem[];
+    /** Retrieves a list of countries with names in their native languages. @keywords national countries, native names */
+    getNational(codes?: string[], sort?: boolean): GeoFlagNational[];
+    /** Retrieves a list of languages with their native names. @keywords national languages, native names */
+    getNationalLanguage(codes?: string[], sort?: boolean): GeoFlagNational[];
+    /** Updates the current country/language code. @keywords set code, update locale */
+    setCode(code: string): this;
+}
+
+/** Cookie key for storing the geo code. @keywords cookie, geo_key */
+export declare const UI_GEO_COOKIE_KEY = "ui-geo-code";
+/** Base class for managing geographic data, location, language, and timezone settings. @keywords geo, location, language, timezone */
+export declare class GeoInstance {
+    /** Initializes the geographic instance and resolves default location data. @keywords constructor, geo, init */
+    constructor();
+    /** Retrieves full geographic data for the current country. @keywords current, country, geo */
+    get(): GeoItemFull;
+    /** Retrieves the current country code. @keywords country, code */
+    getCountry(): string;
+    /** Retrieves the current language code. @keywords language, code */
+    getLanguage(): string;
+    /** Retrieves the standardized locale string (language-country). @keywords standard, locale, language, country */
+    getStandard(): string;
+    /** Retrieves the first day of the week for the current country. @keywords first_day, week, calendar */
+    getFirstDay(): string;
+    /** Retrieves the current raw location string. @keywords location */
+    getLocation(): string;
+    /** Extracts the country code from the current location. @keywords location, country */
+    getLocationCountry(): string;
+    /** Extracts the language code from the current location. @keywords location, language */
+    getLocationLanguage(): string;
+    /** Retrieves processed geographic item data including active language. @keywords item, language, geo */
+    getItem(): GeoItemFull;
+    /** Retrieves the complete list of available country geo records. @keywords list, countries */
+    getList(): GeoItem[];
+    /** Retrieves full geographic data by locale, country, or language code. @keywords by_code, search, locale */
+    getByCode(code?: string): GeoItemFull;
+    /** Retrieves geographic data matching an exact language-country standard code. @keywords by_code_full, lookup */
+    getByCodeFull(code: string): GeoItem | undefined;
+    /** Retrieves geographic data by country code. @keywords by_country, lookup */
+    getByCountry(country: string): GeoItem | undefined;
+    /** Retrieves geographic data by language code. @keywords by_language, lookup */
+    getByLanguage(language: string): GeoItem | undefined;
+    /** Retrieves the current timezone offset in minutes. @keywords timezone, offset, minutes */
+    getTimezone(): number;
+    /** Retrieves the formatted timezone offset string (e.g. '+03:00'). @keywords timezone, format */
+    getTimezoneFormat(): string;
+    /** Finds country geo data by code or name. @keywords find, search, country */
+    find(code: string): GeoItemFull;
+    /** Formats a geo item into a standard locale string. @keywords to_standard, format, locale */
+    toStandard(item: GeoItem, language?: string): string;
+    /** Sets the active location code and optionally persists it to storage. @keywords set, location, save */
+    set(code: string, save?: boolean): void;
+    /** Sets the default timezone offset in minutes. @keywords set_timezone, offset */
+    setTimezone(timezone: number): void;
+    /** Sets the default country code or dynamic resolver. @keywords default_value, country */
+    setValueDefault(code?: string | (() => string)): void;
+    /** Adds or merges geographic data for a specific country code. @keywords add, country, merge */
+    add(country: string, item: Partial<GeoItem>): this;
+    /** Adds or merges multiple country geographic records. @keywords add_list, countries, batch */
+    addList(list: Record<string, Partial<GeoItem>>): this;
+}
+
+/** Internationalization and localization utility providing language-sensitive formatting and comparison. @keywords intl localization i18n formatter */
+export declare class GeoIntl {
+    /** Checks if an instance exists for the specified country or locale code. @keywords localization check locale */
+    static isItem(code?: string): boolean;
+    /** Resolves and returns the standard location/locale code. @keywords locale location standard code */
+    static getLocation(code?: string): string;
+    /** Returns a cached or new GeoIntl instance for the specified locale code. @keywords singleton instance factory */
+    static getInstance(code?: string): GeoIntl;
+    /** Creates a new GeoIntl instance for internationalization formatting. @keywords intl constructor init */
+    constructor(code?: string, errorCenter?: ErrorCenterInstance);
+    /** Gets the current country and language locale code. @keywords locale location code */
+    getLocation(): string;
+    /** Returns the first day of the week for the current locale. @keywords first day week calendar */
+    getFirstDay(): string;
+    /** Formats display names for languages, regions, scripts, or currencies. @keywords display names translation region */
+    display(value?: string, typeOptions?: Intl.DisplayNamesOptions['type'] | Intl.DisplayNamesOptions): string;
+    /** Gets the localized display name of a language. @keywords language name locale */
+    languageName(value?: string, style?: Intl.RelativeTimeFormatStyle): string;
+    /** Gets the localized display name of a country or region. @keywords country name region */
+    countryName(value?: string, style?: Intl.RelativeTimeFormatStyle): string;
+    /** Formats a full person name according to locale conventions. @keywords person full name formatting */
+    fullName(last: string, first: string, surname?: string, short?: boolean): string;
+    /** Formats numbers, strings, or bigints with localized numeric formatting. @keywords number format numeric */
+    number(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Gets the localized decimal separator symbol. @keywords decimal separator point */
+    decimal(): string;
+    /** Formats numbers as localized currency strings. @keywords currency money format */
+    currency(value: NumberOrString, currencyOptions?: string | Intl.NumberFormatOptions, numberOnly?: boolean): string;
+    /** Returns the currency symbol or code for a given currency. @keywords currency symbol sign */
+    currencySymbol(currency: string, currencyDisplay?: keyof Intl.NumberFormatOptionsCurrencyDisplayRegistry): string;
+    /** Formats a number with localized measurement units. @keywords unit measure format */
+    unit(value: NumberOrString, unitOptions?: string | Intl.NumberFormatOptions): string;
+    /** Formats digital file sizes into localized unit strings. @keywords file size byte format */
+    sizeFile(value: NumberOrString, unitOptions?: 'byte' | 'kilobyte' | 'megabyte' | 'gigabyte' | 'terabyte' | 'petabyte' | Intl.NumberFormatOptions): string;
+    /** Formats a ratio value (e.g. 0.5) as a localized percentage. @keywords percent percentage format */
+    percent(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats a 0-100 numeric value as a localized percentage. @keywords percentage percent 100 */
+    percentBy100(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats pluralized words matching locale rules (format: one|two|few|many|other|zero). @keywords plural pluralization words */
+    plural(value: NumberOrString, words: string, options?: Intl.PluralRulesOptions, optionsNumber?: Intl.NumberFormatOptions): string;
+    /** Formats date and time values according to locale rules. @keywords date time format */
+    date(value: NumberOrStringOrDate, type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions, hour24?: boolean): string;
+    /** Formats language-sensitive relative time strings (e.g. 'yesterday', 'in 2 days'). @keywords relative time format ago */
+    relative(value: NumberOrStringOrDate, styleOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions, todayValue?: Date): string;
+    /** Formats relative time with a day limit, falling back to absolute date formatting. @keywords relative limit fallback time */
+    relativeLimit(value: NumberOrStringOrDate, limit: number, todayValue?: Date, relativeOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions, dateOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions, type?: GeoDate, hour24?: boolean): string;
+    /** Formats an explicit numeric difference and time unit into relative time. @keywords relative by value time unit */
+    relativeByValue(value: NumberOrString, unit: Intl.RelativeTimeFormatUnit, styleOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions): string;
+    /** Gets the localized month name for a given date. @keywords month name calendar */
+    month(value?: NumberOrStringOrDate, style?: Intl.DateTimeFormatOptions['month']): string;
+    /** Returns an array of localized month names (1-12). @keywords months list options select */
+    months(style?: Intl.DateTimeFormatOptions['month']): ItemValue<number | undefined>[];
+    /** Gets the localized weekday name for a given date. @keywords weekday name day */
+    weekday(value?: NumberOrStringOrDate, style?: Intl.DateTimeFormatOptions['weekday']): string;
+    /** Returns an array of localized weekday names (0-6). @keywords weekdays list options select */
+    weekdays(style?: Intl.DateTimeFormatOptions['weekday']): ItemValue<number | undefined>[];
+    /** Formats the time portion of a date according to locale conventions. @keywords time format clock */
+    time(value: NumberOrStringOrDate): string;
+    /** Sorts string items or objects locale-sensitively using Intl.Collator. @keywords sort collator locale */
+    sort<T>(data: T[], compareFn?: (a: T, b: T) => [string, string]): T[];
+}
+
+/** Class for storing and processing phone number masks and country dialing codes. @keywords phone, mask, country code, dialing */
+export declare class GeoPhone {
+    /** Retrieves phone code and country information by country code. @keywords phone info, country code */
+    static get(code: string): GeoPhoneValue | undefined;
+    /** Retrieves country and mask information from a phone number. @keywords parse phone, phone lookup */
+    static getByPhone(phone: string): GeoPhoneMapInfo;
+    /** Retrieves complete phone mask data by country code. @keywords mask by code, country mask */
+    static getByCode(code: string): GeoPhoneMap | undefined;
+    /** Returns a list of all phone country codes and metadata. @keywords phone list, country codes */
+    static getList(): GeoPhoneValue[];
+    /** Returns a map tree of phone data indexed by country code. @keywords phone map, dial tree */
+    static getMap(): Record<string, GeoPhoneMap>;
+    /** Formats a phone number according to provided or matched masks. @keywords format phone, apply mask */
+    static toMask(phone: string, masks?: string[]): string | undefined;
+    /** Removes country prefixes or trunk zeroes from an input phone number. @keywords clean phone, strip prefix */
+    static removeZero(phone: string): string;
+}
+
+/** Localized unit formatting and automatic conversions based on locale. @keywords unit measurement locale conversion format */
+export declare class GeoUnit {
+    /** Gets an isolated or cached GeoUnit instance by country or language code. @keywords instance singleton cache factory */
+    static getInstance(code?: string): GeoUnit;
+    /** Creates a GeoUnit instance for a country or language code. @keywords constructor init */
+    constructor(code?: string);
+    /** Gets the standard location code. @keywords location locale country */
+    getLocation(): string;
+    /** Formats millimeter value, converting to inches for imperial locales. @keywords millimeter mm inch */
+    millimeter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats centimeter value, converting to inches for imperial locales. @keywords centimeter cm inch */
+    centimeter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats meter value, converting to feet for imperial locales. @keywords meter m foot feet */
+    meter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats kilometer value, converting to miles for imperial locales. @keywords kilometer km mile */
+    kilometer(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats square meter value, converting to square feet for imperial locales. @keywords square meter m2 sqft */
+    squareMeter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats hectare value, converting to acres for imperial locales. @keywords hectare ha acre */
+    hectare(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats gram value, converting to ounces for imperial locales. @keywords gram g ounce oz */
+    gram(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats kilogram value, converting to pounds for imperial locales. @keywords kilogram kg pound lb */
+    kilogram(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats metric tonne value, converting to short tons for imperial locales. @keywords tonne ton */
+    tonne(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats milliliter value, converting to fluid ounces for imperial locales. @keywords milliliter ml floz */
+    milliliter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats liter value, converting to gallons for imperial locales. @keywords liter l gallon gal */
+    liter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats Celsius value, converting to Fahrenheit for imperial locales. @keywords celsius fahrenheit temperature */
+    celsius(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats speed in km/h, converting to mph for imperial locales. @keywords kmh mph speed */
+    kilometerPerHour(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
+    /** Formats a numeric value for the specified unit according to locale settings. @keywords format unit locale convert */
+    format(value: NumberOrString, unit: string, options?: Intl.NumberFormatOptions): string;
+}
+
+/** Static utility class for storing and retrieving application-wide global data. @keywords global state storage data */
+export declare class Global {
+    /** Returns global data storage instance. @keywords global storage data */
+    static getItem(): Record<string, any>;
+    /** Returns a value by its property name. @keywords get global value property */
+    static get<R = any>(name: string): R;
+    /** Adds global data (works only once). @keywords add set global data init */
+    static add(data: Record<string, any>): void;
+}
+
+/** Static interface for managing URL hash state via HashInstance. @keywords url hash, router state, hash params */
+export declare class Hash {
+    /** Returns a request-isolated HashInstance. @keywords instance, singleton, context */
+    static getItem(): HashInstance;
+    /** Retrieves a value from the URL hash. @keywords hash get, read url param */
+    static get<T>(name: string, defaultValue?: T | (() => T)): T;
+    /** Sets or updates a value in the URL hash. @keywords hash set, update url param */
+    static set<T>(name: string, callback: T | (() => T)): void;
+    /** Subscribes a listener callback to changes for a specific hash variable. @keywords watch, subscribe, listener, observe */
+    static addWatch<T>(name: string, callback: (value: T) => void): void;
+    /** Unsubscribes a listener callback from hash variable changes. @keywords unwatch, unsubscribe, remove listener */
+    static removeWatch<T>(name: string, callback: (value: T) => void): void;
+    /** Reloads and synchronizes hash variables from the current URL string. @keywords reload, refresh, sync url */
+    static reload(): void;
+}
+
+/** Class for managing and synchronizing data stored in the URL hash. @keywords url hash, location hash, hash state, url parameters */
+export declare class HashInstance extends UrlInstanceAbstract {
+}
+
+export type IconsItem = string | Promise<string | any> | (() => Promise<string | any>);
+export type IconsConfig = {
+    url?: string;
+    list?: Record<string, IconsItem>;
+};
+/** Icon manager utility for registering and loading icons. @keywords icons, icon-loader, assets */
+export declare class Icons {
+    /** Checks if an icon is registered. @keywords icons, has-icon, exists */
+    static is(index: string): boolean;
+    /** Retrieves icon content or path asynchronously. @keywords get-icon, async-icon, fetch-icon */
+    static get(index: string, url?: string, wait?: number): Promise<string>;
+    /** Synchronously returns an icon if loaded or string-based. @keywords get-sync, cached-icon */
+    static getAsync(index: string, url?: string): string;
+    /** Retrieves a list of all registered icon names. @keywords icon-list, names */
+    static getNameList(): string[];
+    /** Retrieves the global icon storage URL. @keywords global-url, base-url */
+    static getUrlGlobal(): string;
+    /** Registers a custom icon definition. @keywords register-icon, add-icon */
+    static add(index: string, file: IconsItem): void;
+    /** Registers an icon in pending loading state. @keywords add-loading, placeholder */
+    static addLoad(index: string): void;
+    /** Registers a global icon path. @keywords add-global, icon-url */
+    static addGlobal(index: string, file: string): void;
+    /** Registers multiple icons from a key-value record. @keywords batch-register, icon-list */
+    static addByList(list: Record<string, IconsItem>): void;
+    /** Sets the base icon storage URL. @keywords set-url, icon-path */
+    static setUrl(url: string): void;
+    /** Updates the icon configuration. @keywords config, setup */
+    static setConfig(config: IconsConfig): void;
+}
+
+/** Class for managing global loading state. @keywords loading, loader, spinner, global */
+export declare class Loading {
+    /** Checks if the loader is currently active. @keywords is loading, active */
+    static is(): boolean;
+    /** Gets the current loading count or value. @keywords loading count, status */
+    static get(): number;
+    /** Returns a request-isolated instance of LoadingInstance. @keywords loading instance, isolated */
+    static getItem(): LoadingInstance;
+    /** Shows the loader. @keywords show loader, start loading */
+    static show(): void;
+    /** Hides the loader. @keywords hide loader, stop loading */
+    static hide(): void;
+    /** Registers an event listener for loading state changes. @keywords loading event, add listener */
+    static registrationEvent(listener: EventListenerDetail<CustomEvent, LoadingDetail>, element?: ElementOrString<HTMLElement>): void;
+    /** Unregisters a loading state event listener. @keywords remove listener, unsubscribe */
+    static unregistrationEvent(listener: EventListenerDetail<CustomEvent, LoadingDetail>, element?: ElementOrString<HTMLElement>): void;
+}
+
+export type LoadingDetail = {
+    loading: boolean;
+};
+
+export type LoadingRegistrationItem = {
+    item: EventItem<Window, CustomEvent, LoadingDetail>;
+    listener: EventListenerDetail<CustomEvent, LoadingDetail>;
+    element?: ElementOrString<HTMLElement>;
+};
+
+/** Manages global loading state counters and event notifications. @keywords loading, state, loader, progress */
+export declare class LoadingInstance {
+    /** Initializes the loading tracker. @param eventName Name of the event to broadcast loading state @keywords init, constructor */
+    constructor(eventName?: string);
+    /** Checks whether the loader is currently active. @keywords is, status, active */
+    is(): boolean;
+    /** Gets the current loading count value. @keywords get, count, counter */
+    get(): number;
+    /** Increments loading counter and activates loader. @keywords show, start, display */
+    show(): void;
+    /** Decrements loading counter and hides loader when count reaches zero. @keywords hide, stop, dismiss */
+    hide(): void;
+    /** Registers an event listener for loading state changes. @param listener Event listener callback @param element Target DOM element @keywords register, listener, subscribe */
+    registrationEvent(listener: EventListenerDetail<CustomEvent, LoadingDetail>, element?: ElementOrString<HTMLElement>): void;
+    /** Unregisters a loading state event listener. @param listener Event listener callback @param element Target DOM element @keywords unregister, unsubscribe, remove */
+    unregistrationEvent(listener: EventListenerDetail<CustomEvent, LoadingDetail>, element?: ElementOrString<HTMLElement>): void;
+}
+
+/** Unified manager for standard HTML, Open Graph, and Twitter Card meta tags. @keywords meta, tags, head, html, seo */
+export declare class Meta extends MetaManager<MetaTag[]> {
+    /** Creates an instance of Meta with integrated Open Graph and Twitter Card support. @keywords constructor, init */
+    constructor();
+    /** Gets the MetaOg instance for Open Graph operations. @keywords og, opengraph */
+    getOg(): MetaOg;
+    /** Gets the MetaTwitter instance for Twitter Card operations. @keywords twitter, card */
+    getTwitter(): MetaTwitter;
+    /** Gets the page title without suffix. @keywords title, get */
+    getTitle(): string;
+    /** Gets the keywords meta tag content. @keywords keywords, get */
+    getKeywords(): string;
+    /** Gets the description meta tag content. @keywords description, get */
+    getDescription(): string;
+    /** Gets the Open Graph image URL. @keywords image, og, get */
+    getImage(): string;
+    /** Gets the canonical URL. @keywords canonical, url, get */
+    getCanonical(): string;
+    /** Gets the robots meta tag directive. @keywords robots, crawler, get */
+    getRobots(): MetaRobots;
+    /** Gets the author meta tag content. @keywords author, get */
+    getAuthor(): string;
+    /** Gets the Open Graph site name. @keywords site_name, og, get */
+    getSiteName(): string;
+    /** Gets the Open Graph locale. @keywords locale, og, get */
+    getLocale(): string;
+    /** Sets the page title with suffix and updates Open Graph and Twitter Card titles. @keywords title, set */
+    setTitle(title: string): this;
+    /** Sets the keywords meta tag. @keywords keywords, set */
+    setKeywords(keywords: string | string[]): this;
+    /** Sets the description meta tag. @keywords description, set */
+    setDescription(description: string): this;
+    /** Sets the image for Open Graph and Twitter Card. @keywords image, og, twitter, set */
+    setImage(image: string): this;
+    /** Sets the canonical URL and updates Open Graph and Twitter Card URLs. @keywords canonical, url, set */
+    setCanonical(canonical: string): this;
+    /** Sets the robots meta tag directive. @keywords robots, indexing, set */
+    setRobots(robots: MetaRobots): this;
+    /** Sets the author meta tag. @keywords author, set */
+    setAuthor(author: string): this;
+    /** Sets the site name for Open Graph and Twitter Card. @keywords site_name, og, set */
+    setSiteName(siteName: string): this;
+    /** Sets the Open Graph locale. @keywords locale, og, set */
+    setLocale(locale: string): this;
+    /** Sets the suffix to append to page title. @keywords suffix, title, set */
+    setSuffix(suffix?: string): void;
+    /** Generates the complete HTML string for all meta tags. @keywords html, render, serialize */
+    html(): string;
+    /** Generates the title as an HTML-safe string. @keywords title, html, render */
+    htmlTitle(): string;
+}
+
+type MetaList<T extends readonly string[]> = {
+    [K in T[number]]?: string;
+};
+/** Manages HTML meta tag creation, retrieval, and rendering. @keywords meta, head, seo, html, tags */
+export declare class MetaManager<T extends readonly string[], Key extends keyof MetaList<T> = keyof MetaList<T>> {
+    /** Initializes manager with meta tag names and optional property attribute mode. @keywords meta, init, head */
+    constructor(listMeta: T, isProperty?: boolean);
+    /** Returns managed meta tag names list. @keywords meta, list, names */
+    getListMeta(): T;
+    /** Gets content of specified meta tag by name. @keywords meta, get, value, content */
+    get(name: Key): string;
+    /** Returns all configured meta tag key-value pairs. @keywords meta, items, dictionary, all */
+    getItems(): MetaList<T>;
+    /** Renders all meta tags as an HTML string. @keywords html, render, markup, meta */
+    html(): string;
+    /** Sets content for a specific meta tag. @keywords meta, set, update */
+    set(name: Key, content: string): this;
+    /** Sets multiple meta tags from a dictionary object. @keywords meta, batch, set, dictionary */
+    setByList(metaList: MetaList<T>): this;
+}
+
+/** Manages Open Graph meta tags. @keywords meta open graph og seo tags */
+export declare class MetaOg extends MetaManager<MetaOpenGraphTag[]> {
+    /** Initializes a new MetaOg instance. @keywords constructor og */
+    constructor();
+    /** Gets the Open Graph title (`og:title`). @keywords og title */
+    getTitle(): string;
+    /** Gets the Open Graph type (`og:type`). @keywords og type */
+    getType(): MetaOpenGraphType;
+    /** Gets the Open Graph URL (`og:url`). @keywords og url */
+    getUrl(): string;
+    /** Gets the Open Graph image URL (`og:image`). @keywords og image */
+    getImage(): string;
+    /** Gets the Open Graph description (`og:description`). @keywords og description */
+    getDescription(): string;
+    /** Gets the Open Graph locale (`og:locale`). @keywords og locale */
+    getLocale(): string;
+    /** Gets the Open Graph site name (`og:site_name`). @keywords og site name */
+    getSiteName(): string;
+    /** Sets the Open Graph title (`og:title`). @keywords og title */
+    setTitle(title: string): this;
+    /** Sets the Open Graph type (`og:type`). @keywords og type */
+    setType(type: MetaOpenGraphType): this;
+    /** Sets the Open Graph URL (`og:url`). @keywords og url */
+    setUrl(url: string): this;
+    /** Sets the Open Graph image URL (`og:image`). @keywords og image */
+    setImage(url: string): this;
+    /** Sets the Open Graph description (`og:description`). @keywords og description */
+    setDescription(description: string): this;
+    /** Sets the Open Graph locale (`og:locale`, e.g. 'en_US'). @keywords og locale */
+    setLocale(locale: string): this;
+    /** Sets the Open Graph site name (`og:site_name`). @keywords og site name */
+    setSiteName(siteName: string): this;
+}
+
+/** Static helper for managing meta tags, Open Graph, and Twitter Cards. @keywords meta, tags, head, seo */
+export declare class MetaStatic {
+    /** Returns singleton instance of Meta. @keywords instance, singleton, meta */
+    static getItem(): Meta;
+    /** Returns MetaOg instance for Open Graph tags. @keywords og, open graph, social */
+    static getOg(): MetaOg;
+    /** Returns MetaTwitter instance for Twitter Card tags. @keywords twitter, twitter card, social */
+    static getTwitter(): MetaTwitter;
+    /** Gets page title without suffix. @keywords title, get, seo */
+    static getTitle(): string;
+    /** Gets keywords meta tag content. @keywords keywords, meta, seo */
+    static getKeywords(): string;
+    /** Gets description meta tag content. @keywords description, meta, seo */
+    static getDescription(): string;
+    /** Gets Open Graph image URL. @keywords image, og, preview */
+    static getImage(): string;
+    /** Gets canonical URL. @keywords canonical, url, link */
+    static getCanonical(): string;
+    /** Gets robots meta directive. @keywords robots, crawler, indexing */
+    static getRobots(): MetaRobots;
+    /** Gets author meta tag value. @keywords author, meta */
+    static getAuthor(): string;
+    /** Gets Open Graph site name. @keywords siteName, og, name */
+    static getSiteName(): string;
+    /** Gets Open Graph locale. @keywords locale, language, og */
+    static getLocale(): string;
+    /** Sets page title and synchronizes Open Graph and Twitter Card titles. @keywords setTitle, title, seo */
+    static setTitle(title: string): typeof MetaStatic;
+    /** Sets keywords meta tag. @keywords setKeywords, keywords, seo */
+    static setKeywords(keywords: string | string[]): typeof MetaStatic;
+    /** Sets description meta tag. @keywords setDescription, description, seo */
+    static setDescription(description: string): typeof MetaStatic;
+    /** Sets preview image for Open Graph and Twitter Card. @keywords setImage, image, og, twitter */
+    static setImage(image: string): typeof MetaStatic;
+    /** Sets canonical URL and updates Open Graph and Twitter Card URLs. @keywords setCanonical, canonical, url */
+    static setCanonical(canonical: string): typeof MetaStatic;
+    /** Sets robots meta tag directive. @keywords setRobots, robots, crawler */
+    static setRobots(robots: MetaRobots): typeof MetaStatic;
+    /** Sets author meta tag. @keywords setAuthor, author */
+    static setAuthor(author: string): typeof MetaStatic;
+    /** Sets site name for Open Graph and Twitter Card. @keywords setSiteName, siteName, og */
+    static setSiteName(siteName: string): typeof MetaStatic;
+    /** Sets locale for Open Graph. @keywords setLocale, locale, lang */
+    static setLocale(locale: string): typeof MetaStatic;
+    /** Sets suffix appended to page title. @keywords setSuffix, suffix, title */
+    static setSuffix(suffix?: string): typeof MetaStatic;
+    /** Renders complete HTML string for all meta, Open Graph, and Twitter Card tags. @keywords html, render, tags */
+    static html(): string;
+    /** Renders page title tag as HTML-safe string. @keywords htmlTitle, title, render */
+    static htmlTitle(): string;
+}
+
+/** Manages Twitter Card meta tags. @keywords twitter card, meta tags, social share */
+export declare class MetaTwitter extends MetaManager<MetaTwitterTag[]> {
+    /** Initializes the MetaTwitter instance. @keywords constructor, init */
+    constructor();
+    /** Gets the Twitter Card type. @keywords twitter card, type, get */
+    getCard(): MetaTwitterCard;
+    /** Gets the website or brand @username. @keywords twitter site, username, get */
+    getSite(): string;
+    /** Gets the content creator @username. @keywords twitter creator, author, get */
+    getCreator(): string;
+    /** Gets the page URL. @keywords twitter url, get */
+    getUrl(): string;
+    /** Gets the card title. @keywords twitter title, get */
+    getTitle(): string;
+    /** Gets the card description. @keywords twitter description, get */
+    getDescription(): string;
+    /** Gets the card image URL. @keywords twitter image, get */
+    getImage(): string;
+    /** Sets the Twitter Card type. @keywords twitter card, type, set */
+    setCard(card: MetaTwitterCard): this;
+    /** Sets the website or brand @username. @keywords twitter site, username, set */
+    setSite(site: string): this;
+    /** Sets the content creator @username. @keywords twitter creator, author, set */
+    setCreator(creator: string): this;
+    /** Sets the page URL. @keywords twitter url, set */
+    setUrl(url: string): this;
+    /** Sets the card title. @keywords twitter title, set */
+    setTitle(title: string): this;
+    /** Sets the card description. @keywords twitter description, set */
+    setDescription(description: string): this;
+    /** Sets the card image URL. @keywords twitter image, set */
+    setImage(image: string): this;
+}
+
+/** Static facade for managing URL query parameters. @keywords url, query params, search params, routing */
+export declare class Query {
+    /** Returns a request-isolated QueryInstance. @keywords instance, query instance, singleton */
+    static getItem(): QueryInstance;
+    /** Retrieves a parameter value from the query string with an optional default. @keywords get query, query parameter, read url */
+    static get<T>(name: string, defaultValue?: T | (() => T)): T;
+    /** Sets or updates a parameter in the URL query string. @keywords set query, update query, write url */
+    static set<T>(name: string, callback: T | (() => T)): void;
+    /** Subscribes a listener to changes for a specific query parameter. @keywords watch, query listener, observer, event */
+    static addWatch<T>(name: string, callback: (value: T) => void): void;
+    /** Unsubscribes a listener from changes for a specific query parameter. @keywords unwatch, remove listener, unsubscribe */
+    static removeWatch<T>(name: string, callback: (value: T) => void): void;
+    /** Synchronizes query state with the current URL search string. @keywords reload query, sync url, refresh query */
+    static reload(): void;
+}
+
+/** Manages data stored in URL query parameters. @keywords query, url, searchParams, parameters */
+export declare class QueryInstance extends UrlInstanceAbstract {
+}
+
+/** Timer that can be paused, resumed, reset, and cleared. @keywords timer, pause, resume, timeout, delay */
+export declare class ResumableTimer {
+    /** Creates a resumable timer instance. @param blockStart If true, timer will not start immediately. @keywords timer, init */
+    constructor(callback: FunctionVoid, delay?: number, blockStart?: boolean);
+    /** Resumes the timer if paused, or starts it. @keywords resume, start, continue */
+    resume(): this;
+    /** Pauses the timer and tracks remaining time. @keywords pause, stop, hold */
+    pause(): this;
+    /** Resets and restarts the timer with the original delay. @keywords reset, restart */
+    reset(): this;
+    /** Completely clears and cancels the timer. @keywords clear, cancel, destroy */
+    clear(): this;
+}
+
+/** Utility class for calculating and managing scrollbar width. @keywords scrollbar, scroll width, layout, measurement */
+export declare class ScrollbarWidth {
+    /** Checks whether scrollbar hiding should be enabled. @keywords scrollbar, visibility, check, hide */
+    static is(): Promise<boolean>;
+    /** Computes and returns the scrollbar width in pixels. @keywords scrollbar, width, measure, pixels */
+    static get(): Promise<number>;
+    /** Returns the storage instance holding the cached scrollbar width. @keywords scrollbar, storage, cache */
+    static getStorage(): DataStorage<number>;
+    /** Checks if scrollbar width calculation is currently in progress. @keywords scrollbar, calculate, state, status */
+    static getCalculate(): boolean;
+}
+
+/** Manages searchable lists, coordinating options, item state, matching logic, and storage. @keywords search, list, filter, data */
+export declare class SearchList<T extends SearchItem, K extends SearchColumns<T>> {
+    /** Initializes a new SearchList instance. @keywords search list, constructor */
+    constructor(list: SearchListValue<T>, columns?: K, value?: string, options?: SearchOptions);
+    /** Gets the search data management instance. @keywords search data, storage */
+    getData(): SearchListData<T, K>;
+    /** Gets the current list of items. @keywords list, items, search list */
+    getList(): SearchListValue<T>;
+    /** Gets the active search columns. @keywords columns, fields, search columns */
+    getColumns(): K | undefined;
+    /** Gets the search item instance. @keywords item, search item */
+    getItem(): SearchListItem;
+    /** Gets the current search query value. @keywords query, search value */
+    getValue(): string | undefined;
+    /** Gets the search options manager instance. @keywords options, configuration, search options */
+    getOptions(): SearchListOptions;
+    /** Sets a new list of items and resets the cache. @keywords set list, update items */
+    setList(list: SearchListValue<T>): this;
+    /** Sets target search columns and resets the cache. @keywords set columns, search fields */
+    setColumns(columns?: K): this;
+    /** Sets the search query value and updates the matcher. @keywords set value, search query */
+    setValue(value?: string): this;
+    /** Sets search options and updates the matcher. @keywords set options, configuration */
+    setOptions(options: SearchOptions): this;
+    /** Processes and returns the formatted list based on the current search state. @keywords format, process, filter results */
+    to(): SearchFormatList<T, K>;
+}
+
+/** Manages and formats search data list and item cache. @keywords search, list, cache, format */
+export declare class SearchListData<T extends SearchItem, K extends SearchColumns<T>> {
+    /** Creates an instance of SearchListData. @keywords constructor, init */
+    constructor(list: SearchListValue<T>, columns: K | undefined, item: SearchListItem, options: SearchListOptions);
+    /** Checks if both list and columns are provided for column-based search. @keywords type guard, check, columns */
+    is(): this is this & {
+        list: T[];
+        columns: string[];
+    };
+    /** Checks if the search list is provided. @keywords type guard, check, list */
+    isList(): this is this & {
+        list: T[];
+    };
+    /** Returns the original list. @keywords get list, source */
+    getList(): SearchListValue<T>;
+    /** Returns search columns. @keywords get columns, keys */
+    getColumns(): K | undefined;
+    /** Sets a new list and updates the cache. @keywords set list, cache */
+    setList(list: SearchListValue<T>): this;
+    /** Sets search columns and updates the cache. @keywords set columns, cache */
+    setColumns(columns?: SearchColumns<T>): this;
+    /** Finds a cached item for the given original item. @keywords find, cache, lookup */
+    findCacheItem(item: T): SearchCacheItem<T> | undefined;
+    /** Iterates over cached items and applies a formatting callback. @keywords iterate, format, callback */
+    forEach(callback: (item: SearchCacheItem<T>['item'], value: SearchCacheItem<T>['value']) => SearchFormatItem<T, K> | undefined): SearchFormatList<T, K>;
+    /** Formats an item, optionally highlighting matching search terms. @keywords format item, highlight, match */
+    toFormatItem(item: T, selection: boolean): SearchFormatItem<T, K>;
+}
+
+/** Manages search item value and query state. @keywords search item value query state */
+export declare class SearchListItem {
+    /** Initializes a new SearchListItem instance. @keywords search item constructor init */
+    constructor(value: string | undefined, options: SearchListOptions);
+    /** Checks whether the search value is defined. @keywords check value exists defined */
+    is(): this is this & {
+        value: string;
+    };
+    /** Checks if the search value length meets the minimum limit. @keywords search threshold limit length */
+    isSearch(): boolean;
+    /** Gets the current search string value. @keywords get search query string */
+    get(): string;
+    /** Sets the search string value. @keywords set search query update */
+    set(value?: string): this;
+}
+
+/** Matches search values against list data using regular expressions. @keywords search matcher regex pattern */
+export declare class SearchListMatcher {
+    /** Initializes the search matcher with item and options. @keywords constructor init */
+    constructor(item: SearchListItem, options: SearchListOptions);
+    /** Checks if the matcher is active or initialized. @keywords is initialized check active */
+    is(): boolean;
+    /** Checks if the given value matches the current search expression. @keywords test match selection */
+    isSelection(value: SearchCacheItem<any>['value']): boolean;
+    /** Gets the compiled regular expression matcher. @keywords regex pattern get */
+    get(): RegExp | undefined;
+    /** Updates the regex matcher from current item value and options. @keywords update refresh compile */
+    update(): void;
+}
+
+/** Manages search list options and configuration settings. @keywords search, options, list, config */
+export declare class SearchListOptions {
+    /** Initializes search list options. @keywords constructor, init */
+    constructor(options?: SearchOptions | undefined);
+    /** Retrieves current search options. @keywords get, options, search */
+    getOptions(): SearchOptions;
+    /** Retrieves the minimum character length required to trigger search. @keywords limit, min, length, trigger */
+    getLimit(): number;
+    /** Checks if all items are returned regardless of search match. @keywords return, all, match, filter */
+    getReturnEverything(): boolean;
+    /** Retrieves search debounce delay in milliseconds. @keywords delay, debounce, time */
+    getDelay(): number;
+    /** Checks whether exact match searching is enabled. @keywords exact, match, strict */
+    getFindExactMatch(): boolean;
+    /** Retrieves the CSS class name used for highlighting matches. @keywords class, highlight, css */
+    getClassName(): string;
+    /** Updates search options. @keywords set, options, update */
+    setOptions(options: SearchOptions): this;
+}
+
+type ServerStorageItem = {
+    value: any;
+    hydration: boolean;
+};
+type ServerStorageList = Record<string, ServerStorageItem>;
+/** Manages isolated data storage during SSR across parallel requests. @keywords ssr, storage, isolation, context */
+export declare class ServerStorage {
+    /** Initializes storage with a request context listener function. @keywords init, context, ssr */
+    static init(listener: () => Record<string, any> | undefined): typeof ServerStorage;
+    /** Resets the storage state. @keywords reset, clear */
+    static reset(): void;
+    /** Checks if a value exists in storage by key. @keywords has, exists, key */
+    static has(key: string): boolean;
+    /** Retrieves a value or creates it using a factory function with optional hydration. @keywords get, hydration, cache */
+    static get<T = any>(key: string, defaultValue?: () => T, hydration?: boolean): T;
+    /** Stores a value from a factory function with optional hydration. @keywords set, store, hydration */
+    static set<T = any>(key: string, value: () => T, hydration?: boolean, storageList?: ServerStorageList): T;
+    /** Sets whether error messages should be hidden or shown. @keywords error, status, logging */
+    static setErrorStatus(hide: boolean): void;
+    /** Removes a value from storage by key. @keywords remove, delete */
+    static remove(key: string): void;
+    /** Serializes the hydration storage into an executable script tag string. @keywords hydration, serialize, toString */
+    static toString(): string;
+}
+export {};
+
+/** Manages storage callback lists and execution state. @keywords storage callback subscriber listener */
+export declare class StorageCallback<T = any, Callback = (value: T) => void | Promise<void>> {
+    /** Gets a StorageCallback singleton instance by name and group. @keywords singleton instance storage */
+    static getInstance<T>(name: string, group?: string): StorageCallback<T, (value: T) => void | Promise<void>>;
+    /** Initializes a new StorageCallback instance. @keywords constructor init */
+    constructor(name: string, group?: string);
+    /** Checks whether storage is currently in a loading state. @keywords loading state check */
+    isLoading(): boolean;
+    /** Gets the storage identifier name. @keywords name identifier */
+    getName(): string;
+    /** Gets the current loading state value. @keywords loading status */
+    getLoading(): boolean;
+    /** Subscribes a callback function to storage events. @keywords subscribe listener add once */
+    addCallback(callback: Callback, isOnce?: boolean): this;
+    /** Unsubscribes a callback function from storage events. @keywords unsubscribe listener remove */
+    removeCallback(callback: Callback): this;
+    /** Prepares storage callback state prior to execution. @keywords prepare init state */
+    preparation(): this;
+    /** Executes all registered callbacks asynchronously with the provided value. @keywords trigger emit execute dispatch */
+    run(value: T): Promise<this>;
+}
+
+/** Translation service for loading and resolving localized texts. @keywords translate, i18n, localization, dictionary */
+export declare class Translate {
+    /** Asynchronously retrieves translation text by code with optional replacements. @keywords translate, get, async, i18n */
+    static get(name: string, replacement?: string[] | Record<string, string | number>): Promise<string>;
+    /** Returns a request-isolated TranslateInstance. @keywords translate, instance, context */
+    static getItem(): TranslateInstance;
+    /** Synchronously retrieves translation text by code with optional replacements. @keywords translate, sync, lookup */
+    static getSync(name: string, first?: boolean, replacement?: string[] | Record<string, string | number>): string;
+    /** Asynchronously retrieves multiple translations by key list. @keywords translate, list, batch, async */
+    static getList<T extends TranslateCode[]>(names: T): Promise<TranslateList<T>>;
+    /** Synchronously retrieves multiple translations by key list. @keywords translate, list, sync */
+    static getListSync<T extends TranslateCode[]>(names: T, first?: boolean): TranslateList<T>;
+    /** Asynchronously loads translated texts for specified codes. @keywords translate, add, load, async */
+    static add(names: string | string[]): Promise<void>;
+    /** Synchronously registers a dictionary of key-value translations. @keywords translate, addSync, register, dictionary */
+    static addSync(data: Record<string, string>): void;
+    /** Adds translation data via request or directly depending on environment. @keywords translate, add, hybrid */
+    static addNormalOrSync(data: Record<string, string>): Promise<void>;
+    /** Synchronously registers translations grouped by location. @keywords translate, location, namespace */
+    static addSyncByLocation(data: Record<string, Record<string, string>>): void;
+    /** Synchronously registers translations from a structured translation file. @keywords translate, file, import */
+    static addSyncByFile(data: TranslateDataFile): void;
+    /** Sets the endpoint URL for translation requests. @keywords translate, url, endpoint */
+    static setUrl(url: string): void;
+    /** Sets the property name used to resolve translations. @keywords translate, property, config */
+    static setPropsName(name: string): void;
+    /** Toggles the API read mode for fetching translations. @keywords translate, api, mode */
+    static setReadApi(value: boolean): void;
+    /** Applies translation service configuration. @keywords translate, config, options */
+    static setConfig(config: TranslateConfig): void;
+}
+
+/** Manages translation file loading and resolution based on language and location. @keywords translation, localization, i18n, files, translate */
+export declare class TranslateFile {
+    /** Creates an instance of TranslateFile. @keywords constructor, init */
+    constructor(data?: TranslateDataFile, language?: string | (() => string), location?: string | (() => string));
+    /** Checks if translation files exist for the current location or language. @keywords isFile, check, exists */
+    isFile(): boolean;
+    /** Retrieves the current location identifier. @keywords getLocation, location, path */
+    getLocation(): string;
+    /** Retrieves the current active language code. @keywords getLanguage, language, locale, i18n */
+    getLanguage(): string;
+    /** Loads and returns the translation data list for the current location. @keywords getList, load, translations, async */
+    getList(): Promise<TranslateDataFileList | undefined>;
+    /** Registers additional translation file data sources. @keywords add, register, files */
+    add(data: TranslateDataFile): void;
+}
+
+/** Translation management instance for fetching and resolving localized strings. @keywords translate, i18n, localization, locale */
+export declare class TranslateInstance {
+    /** Initializes a new translation instance with optional endpoint and files. @keywords init, translate */
+    constructor(url?: string, propsName?: string, files?: TranslateFile);
+    /** Fetches translation text asynchronously by code with optional replacements. @keywords get, translate, async */
+    get(name: string, replacement?: string[] | Record<string, string | number>): Promise<string>;
+    /** Gets translation text synchronously by code with optional fallback and replacements. @keywords getSync, translate, sync */
+    getSync(name: string, first?: boolean, replacement?: string[] | Record<string, string | number>): string;
+    /** Fetches multiple translations asynchronously by code array. @keywords getList, batch, translate */
+    getList<T extends TranslateCode[]>(names: T): Promise<TranslateList<T>>;
+    /** Gets multiple translations synchronously by code array. @keywords getListSync, batch, sync */
+    getListSync<T extends TranslateCode[]>(names: T, first?: boolean): TranslateList<T>;
+    /** Adds translation codes to be loaded. @keywords add, load, translations */
+    add(names: string | string[]): Promise<void>;
+    /** Adds translation key-value pairs synchronously. @keywords addSync, register, dictionary */
+    addSync(data: Record<string, string>): void;
+    /** Adds translations via network request or directly depending on runtime environment. @keywords addNormalOrSync, environment */
+    addNormalOrSync(data: Record<string, string>): Promise<void>;
+    /** Adds translations grouped by location synchronously. @keywords addSyncByLocation, locale, location */
+    addSyncByLocation(data: Record<string, Record<string, string>>): void;
+    /** Adds translations synchronously from a file data object. @keywords addSyncByFile, file, import */
+    addSyncByFile(data: TranslateDataFile): void;
+    /** Sets the API URL endpoint for fetching translations. @keywords setUrl, config, endpoint */
+    setUrl(url: string): this;
+    /** Sets the property name used for translation lookups. @keywords setPropsName, property, config */
+    setPropsName(name: string): this;
+    /** Toggles the translation API read mode. @keywords setReadApi, mode, config */
+    setReadApi(value: boolean): this;
+}
+
+/** Abstract base class managing URL-based state storage and synchronization. @keywords url, hash, query, state */
+export declare abstract class UrlInstanceAbstract {
+    /** Retrieves stored URL state value or falls back to a default value or factory. @keywords get, url state, read */
+    get<T>(name: string, defaultValue?: T | (() => T)): T;
+    /** Updates URL state variable with a value or transformation callback. @keywords set, update, url state */
+    set<T>(name: string, callback: T | (() => T)): this;
+    /** Subscribes a listener callback to variable change events. @keywords watch, observe, listener, subscribe */
+    addWatch<T>(name: string, callback: (value: T) => void): this;
+    /** Unsubscribes a listener callback from variable change events. @keywords unwatch, unsubscribe, listener */
+    removeWatch<T>(name: string, callback: (value: T) => void): this;
+    /** Reloads and syncs state variables directly from the current URL. @keywords reload, sync, refresh */
+    reload(): this;
+}
+
+/** Isomorphic utility class for URL parsing, manipulation, and query parameter management. @keywords url, parser, query, uri */
+export declare class UrlItem {
+    /** Returns a request-isolated instance of UrlItem. @keywords singleton, instance, request, isolated */
+    static getInstance(): UrlItem;
+    /** Constructs a new UrlItem instance. @param url URL string or URL object @keywords constructor, create, init */
+    constructor(url?: string | URL);
+    /** Full URL string representation. @keywords href, url, link */
+    get href(): string;
+    /** Protocol scheme including trailing colon. @keywords protocol, scheme, http, https */
+    get protocol(): string;
+    /** Username component of URL credentials. @keywords username, auth, credentials */
+    get username(): string;
+    /** Password component of URL credentials. @keywords password, auth, credentials */
+    get password(): string;
+    /** Host containing hostname and port. @keywords host, domain, port */
+    get host(): string;
+    /** Hostname excluding port number. @keywords hostname, domain */
+    get hostname(): string;
+    /** Port number string. @keywords port, network */
+    get port(): string;
+    /** URL path component starting with slash. @keywords pathname, path, route */
+    get pathname(): string;
+    /** Query string including leading question mark. @keywords search, querystring, query */
+    get search(): string;
+    /** Read-only URLSearchParams query parameters object. @keywords searchParams, query, params */
+    get searchParams(): URLSearchParams;
+    /** Fragment identifier including leading hash sign. @keywords hash, fragment, anchor */
+    get hash(): string;
+    /** Read-only origin of the URL (scheme + host). @keywords origin, domain, base */
+    get origin(): string;
+    /** Checks if the specified query parameter exists. @param name Parameter name @keywords hasParam, query, exists, search */
+    hasParam(name: string): boolean;
+    /** Gets the value of a specific query parameter. @param name Parameter name @keywords getParam, query, parameter */
+    getParam(name: string): string | undefined;
+    /** Returns all query parameters as an object with transformed types. @keywords getParams, query, search, dictionary */
+    getParams(): Record<string, any>;
+    /** Updates the URL value and reinitializes state. @param url URL string or URL instance @keywords set, update, parse */
+    set(url?: string | URL): this;
+    /** Sets or updates the value of a query parameter. @param name Parameter name @param value Parameter value @keywords setParam, query, update */
+    setParam(name: string, value: string): this;
+    /** Replaces all query parameters with the provided key-value object. @param params Key-value parameter object @keywords setParams, query, batch */
+    setParams(params: Record<string, any>): this;
+    /** Deletes a query parameter by name. @param name Parameter name @keywords deleteParam, remove, query */
+    deleteParam(name: string): this;
+    /** Serializes the URL instance to its full string representation. @keywords toString, serialize, string */
+    toString(): string;
+    /** Serializes the URL instance to a JSON string representation. @keywords toJSON, serialize, json */
+    toJSON(): string;
+}
+
+/** Wraps matched search substrings with an HTML highlight tag. @keywords highlight match search replace tag html */
+export declare function addTagHighlightMatch(value: string, search?: string | RegExp, className?: string, shouldEscape?: boolean): string;
+
+/** Converts any value to a string with optional array formatting and trimming. @keywords anyToString, stringify, to string, convert, cast */
+export declare function anyToString<V>(value: V, isArrayString?: boolean, trim?: boolean): string;
+
+/** Replaces template placeholder keys in square or curly brackets with values from a replacement object or array. @keywords template, string interpolation, placeholder, replace */
+export declare const applyTemplate: (text: string, replacement?: Record<string, string | number | boolean> | string[]) => string;
+
+/** Creates an array of specified length filled with the given value. @keywords array, fill, repeat, populate, initialize */
+export declare function arrFill<T>(value: T, count: number): T[];
+
+/** Converts a Blob to a Base64 string, optionally stripping the data URL prefix. @param clean If true, removes the data URL prefix. @keywords blob, base64, encode, convert */
+export declare function blobToBase64(blob: Blob, clean?: boolean): Promise<string | undefined>;
+
+/** Capitalizes the first letter of a string. @keywords capitalize, uppercase, first letter, string */
+export declare function capitalize(value: string, isLocale?: boolean): string;
+
+/** Creates a deep copy of an object to prevent unwanted mutations. @keywords deep copy, clone, duplicate */
+export declare function copyObject<T>(value: T): T;
+
+/** Copies a simple object with optional additional source properties. @keywords copy, clone, shallow copy, object clone */
+export declare function copyObjectLite<T, R = T>(value: T, source?: any): R;
+
+/**
+ * Creates an HTML element, applies properties or a setup callback, and inserts it into the DOM.
+ * @remarks Returns `undefined` during SSR. Call within client-only lifecycle hooks (e.g., `onMounted`, `useEffect`) to prevent hydration mismatches.
+ * @keywords createElement, create dom element, html node, ssr safe
+ */
+export declare function createElement<T extends HTMLElement>(parentElement?: HTMLElement, tagName?: string, options?: Partial<T> | Record<keyof T, T[keyof T]> | ((element: T) => void), referenceElement?: HTMLElement): T | undefined;
+
+/** Executes a callback when the DOM is ready or immediately if already loaded. @keywords dom, ready, domcontentloaded, lifecycle, event */
+export declare function domContentLoaded<T = void>(callback: () => T | Promise<T>): Promise<T>;
+
+/** Selects the first element matching specified CSS selectors. @keywords dom, querySelector, element, find, select */
+export declare function domQuerySelector<E extends Element = Element>(selectors: string): E | undefined;
+
+/** Selects all elements matching the specified selectors. @keywords dom, querySelectorAll, query, selector, elements */
+export declare function domQuerySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E> | undefined;
+
+/** Encodes special characters in a string for safe use in HTML attributes. @keywords html attribute encode escape sanitize */
+export declare function encodeAttribute(text: string): string;
+
+/** Encodes special characters in a string for safe use in HTML attributes. @keywords html attribute encode sanitize escape */
+export declare function encodeLiteAttribute(text: string): string;
+
+/** Resizes an image if it exceeds the maximum size, returning base64 data. @keywords image resize compress max-size base64 */
+export declare function ensureMaxSize(file: Uint8Array, compress?: number, type?: string): Promise<string>;
+
+/** Escapes special regex characters in a string for safe use in a RegExp. @keywords regex, escape, sanitize, regexp */
+export declare function escapeExp(value: string): string;
+
+/** Prevents further propagation of the given event in the DOM. @keywords event, stopPropagation, prevent bubbling */
+export declare function eventStopPropagation(event: Event): void;
+
+/** Executes callback with args if it is a function, otherwise returns value as is. @keywords execute, invoke, call, callback, function, resolve */
+export declare function executeFunction<T>(callback: T | FunctionArgs<any, T>, ...args: any[]): T;
+
+/** Safely executes a sync/async function or resolves a static value in a Promise with provided arguments. @keywords execute, promise, async, runner, callback */
+export declare function executePromise<T>(callback: ((...args: any[]) => Promise<T>) | ((...args: any[]) => T) | T, ...args: any[]): Promise<T>;
+
+/** Iterates over items in an array, record, Map, or Set, executing a callback and returning an array of results. @keywords forEach, iterate, map, loop, collection, transform */
+export declare function forEach<T, R, D extends T[] | Record<string, T> | Map<string, T> | Set<T> = T[] | Record<string, T> | Map<string, T> | Set<T>, K = D extends T[] ? number : string>(data: D & (T[] | Record<string, T> | Map<string, T> | Set<T>), callback: (item: T, key: K, dataMain: typeof data) => R, saveUndefined?: boolean): R[];
+
+/** Cyclically executes a callback via requestAnimationFrame while next returns true, then calls end. @keywords animation, requestAnimationFrame, raf loop, frame */
+export declare function frame(callback: () => void, next?: () => boolean, end?: () => void): void;
+
+/** Splits a string into segments to highlight search matches. @keywords highlight, match, search, split, text */
+export declare function getArrayHighlightMatch(value: string, search?: string | RegExp): HighlightMatchItem[];
+
+/** Retrieves all attributes from the specified DOM element as a key-value map. @keywords get attributes, element attributes, dom attributes */
+export declare function getAttributes<E extends ElementOrWindow>(element?: ElementOrString<E>): Record<string, string | undefined>;
+
+/** Retrieves text data from a clipboard event or the clipboard. @keywords clipboard, paste, copy, read text */
+export declare function getClipboardData(event?: ClipboardEvent): Promise<string>;
+
+/** Extracts an array of values for a specific property or column from an array of objects. @keywords column, pluck, extract, values, property */
+export declare function getColumn<T, K extends keyof T>(array: ObjectOrArray<T>, column: K): (T[K] | undefined)[];
+
+/**
+ * Returns the current date in the specified format.
+ * @remarks Using for SSR rendering may lead to hydration mismatches due to timezone differences. Use within client-side hooks.
+ * @keywords current date, today, now, format, ssr
+ */
+export declare function getCurrentDate(format?: GeoDate): string;
+
+/**
+ * Returns the current time in milliseconds.
+ * @remarks Warning (SSR): Using this function during SSR rendering can cause hydration mismatches due to server/client timestamp differences.
+ * @keywords current time, timestamp, now, milliseconds, epoch
+ */
+export declare function getCurrentTime(): number;
+
+/** Returns the first Element matching the specified selector or the element itself. @keywords getElement, querySelector, dom, selector */
+export declare function getElement<E extends ElementOrWindow, R extends Exclude<E, Window>>(element?: ElementOrString<E>): R | undefined;
+
+/** Returns the element ID or generates a new unique ID if missing. @keywords element id, generate id, get id, dom id */
+export declare function getElementId<E extends ElementOrWindow>(element?: ElementOrString<E>, selector?: string): string;
+/**
+ * Initializes the element ID generator listener for SSR context synchronization.
+ * @warning Initialization is mandatory for correct functioning of SSR on both server and client sides.
+ * @example
+ * ```typescript
+ * import { useId } from 'vue'
+ * import { initGetElementId } from '@dxtmisha/functional-basic'
+ *
+ * initGetElementId(() => useId())
+ * ```
+ * @keywords init id, ssr id listener, setup getElementId
+ */
+export declare function initGetElementId(newListener: () => string | number): void;
+
+/** Resolves an HTMLImageElement from an image element or source URL string. @keywords image, html image, img element, source */
+export declare function getElementImage(image: HTMLImageElement | string): HTMLImageElement | undefined;
+
+/** Retrieves an element property value by key with an optional fallback. @keywords element, get, property, item, value */
+export declare function getElementItem<T extends ElementOrWindow, K extends keyof T, D>(element: ElementOrString<T>, index: K | string, defaultValue?: D): T[K] | D | undefined;
+
+/** Returns the window or DOM element matching a selector or element reference. @keywords get element, window, dom selector, element or window */
+export declare function getElementOrWindow<E extends ElementOrWindow>(element?: ElementOrString<E>): E | undefined;
+
+/** Generates a safe script tag for data hydration. @keywords safe script tag, data hydration, html script */
+export declare function getElementSafeScript(id: string, data: any): string;
+
+/** Creates a case-insensitive regular expression for an exact match of a phrase without anchors. @keywords regex, regular expression, exact match, search pattern */
+export declare function getExactSearchExp(search: string): RegExp;
+
+/** Creates a RegExp object substituting :value in the pattern with the provided value. @keywords regex regexp pattern match getExp */
+export declare function getExp(value: string, flags?: string, pattern?: string): RegExp;
+
+/** Returns the first element of an array, object, or single value. @keywords first, head, initial, array, object */
+export declare function getFirst<T>(value: T | T[] | Record<string, T>): T | undefined;
+
+/** Retrieves and parses JSON hydration data from a DOM script element. @keywords hydration, json, script tag, dom, parse, ssr */
+export declare function getHydrationData<T>(id: string, defaultValue: T, remove?: boolean): T;
+
+/** Returns the source URL string from an HTMLImageElement or string. @keywords image, src, url, source, element */
+export declare function getImageSrc(image?: HTMLImageElement | string): string;
+
+/** Retrieves a nested value from an object by its path. @keywords get, path, nested, object, property */
+export declare function getItemByPath<T extends Record<string, any>, R = string>(item: T, path: string): R | undefined;
+
+/** Returns the pressed key from a keyboard event. @keywords keyboard, key, event, pressed key */
+export declare function getKey(event: KeyboardEvent): string | number | undefined;
+
+/** Returns the last element of an array or object. @keywords last, tail, array, object */
+export declare function getLast<T>(value: T | T[] | Record<string, T>): T | undefined;
+
+/** Returns the length or size of an Array, Object, Map, Set, or String, returning 0 for unsupported or nullish types. @keywords length, size, count, array, object, map, set, string */
+export declare function getLength(value: any): number;
+
+/** Returns the lengths of all string elements in an array or object. @keywords length, count, elements, array, string length */
+export declare function getLengthOfAllArray(value: ObjectOrArray<string>): number[];
+
+/** Finds the length of the longest string in an array or object. @keywords max length, longest string, array, object */
+export declare function getMaxLengthAllArray(data: ObjectOrArray<string>): number;
+
+/** Returns the length of the shortest string in an array or object. @keywords shortest string, min length, minimum string length */
+export declare function getMinLengthAllArray(data: ObjectOrArray<string>): number;
+
+/** Retrieves the position of the mouse cursor or touch point from an event. @keywords mouse touch coordinates client position cursor */
+export declare function getMouseClient(event: MouseEvent | TouchEvent): ImageCoordinator;
+
+/** Returns the mouse cursor or touch clientX coordinate. @keywords mouse, touch, clientX, cursor position, coordinates */
+export declare function getMouseClientX(event: MouseEvent | TouchEvent): number;
+
+/** Returns the vertical client coordinate (Y) of a mouse or touch event. @keywords mouse, touch, clientY, cursor position, Y coordinate */
+export declare function getMouseClientY(event: MouseEvent | TouchEvent): number;
+
+/** Creates a new object containing only the specified keys from the source object. @keywords pick, filter keys, subset, extract properties */
+export declare function getObjectByKeys<T extends Record<string, any>, K extends keyof T>(data: T, keys: K[]): Pick<T, K>;
+
+/** Removes all properties matching an exception value from an object. @keywords object filter remove undefined clean */
+export declare function getObjectNoUndefined<T extends Record<string | number, any>>(data: T, exception?: any): T;
+
+/** Returns the object if its values are defined, otherwise an empty object. @keywords object fallback default getObjectOrNone */
+export declare function getObjectOrNone<T>(value: T): T & Record<string, any>;
+
+/** Strips special characters, returning only alphanumeric characters and spaces. @keywords sanitize, clean, alphanumeric, strip, text */
+export declare function getOnlyText(text: any): string;
+
+/** Returns a random element from an array, object, or value, or undefined if empty. @keywords random, item, sample, choice, array, object */
+export declare function getRandomItem<T>(value?: T | T[] | Record<string, T>): T | undefined;
+
+/** Generates random text with configurable word count and word length constraints. @keywords random text generator words string placeholder */
+export declare function getRandomText(min: number, max: number, symbol?: string, lengthMin?: number, lengthMax?: number): string;
+
+/** Serializes an object or array into a delimited key-value query string. @keywords serialize, query string, key-value, url params */
+export declare function getRequestString(request: Record<string, any> | any[], sign?: string, separator?: string, subKey?: string): string;
+
+/** Builds a case-insensitive RegExp matching strings containing all space-separated search words in any order. @keywords regex, search, multi-word, lookahead, filter, match */
+export declare function getSearchExp(search: string, limit?: number): RegExp;
+
+/** Creates a case-insensitive regular expression for space-separated word search. @keywords regex, search, pattern, word matching */
+export declare function getSeparatingSearchExp(search: string | RegExp, limit?: number): RegExp;
+
+/** Calculates the step value as a percentage within a min-max range. @keywords step, percent, range, slider, scale */
+export declare function getStepPercent(min: number | undefined, max: number): number;
+
+/** Calculates the step value unit relative to the given min and max range. @keywords step, step value, range, interval */
+export declare function getStepValue(min: number | undefined, max: number): number;
+
+/** Scrolls a container element to a target element with optional centering. @keywords scroll, scroll-to, element, center */
+export declare function goScroll(selector: string, elementTo: HTMLElement | undefined, elementCenter?: HTMLElement): void;
+
+/** Smoothly scrolls the viewport to the specified HTML element with an optional offset. @keywords scroll, smooth, scrollIntoView, viewport, offset */
+export declare function goScrollSmooth<E extends HTMLElement>(element: E, options?: ScrollIntoViewOptions, shift?: number): void;
+
+/** Scrolls the container to make the target element visible. @keywords scroll, scrollTo, scrollIntoView, dom */
+export declare function goScrollTo(element?: HTMLElement, elementTo?: HTMLElement, behavior?: ScrollBehavior): void;
+
+/** Invokes the native sharing mechanism via the Web Share API. @keywords share, web share api, navigator share, device share */
+export declare function handleShare(data: ShareData): Promise<boolean>;
+
+/** Checks if a value exists within the specified array. @keywords inArray, array, includes, contains, search */
+export declare function inArray<T>(array: T[], value: T): boolean;
+
+/** Initializes data for scrollbar offset and scroll control. @keywords scrollbar, offset, scroll control, initialize */
+export declare function initScrollbarOffset(): Promise<void>;
+
+/** Computes the key-based intersection between two objects. @keywords intersect, intersection, key comparison, object keys */
+export declare function intersectKey<T, KT extends keyof T, C, KC extends keyof C>(data?: T, comparison?: C): Record<KT & KC, T[KT]>;
+
+/** Checks if an API response is successful. @keywords api, response, success, check, validate */
+export declare const isApiSuccess: <T>(data: ApiData<T>) => boolean;
+
+/** Checks if a value is an array. @keywords isArray, array, type guard, validation */
+export declare function isArray<T, R>(value: T): value is Extract<T, R[]>;
+
+/** Checks if the values of two objects are different. @keywords compare, difference, object, equality */
+export declare function isDifferent<T>(value: ObjectItem<T>, old: ObjectItem<T>): boolean;
+
+/** Checks if the current environment is a data URL. @keywords isDomData, dom, data url, environment */
+export declare function isDomData(): boolean;
+
+/** Checks if the code is running in a DOM / browser environment where the `window` object is available. @keywords dom runtime browser window environment check */
+export declare function isDomRuntime(): boolean;
+
+/** Checks if an element is visible in the DOM and not hidden by CSS (can be off-screen). @keywords element, dom, visible, visibility, is-visible, display, css */
+export declare function isElementVisible<E extends ElementOrWindow>(elementSelectors?: ElementOrString<E>): boolean;
+
+/** Checks if the pressed key is Enter or Space. @keywords enter, space, keydown, keyboard event, key check */
+export declare const isEnter: (event: KeyboardEvent, isInputElement?: boolean) => boolean;
+
+/** Checks if a value is filled and not empty. @param zeroTrue Treats 0 or '0' as filled if true @keywords isFilled, filled, empty check, validation, presence */
+export declare function isFilled<T>(value: T, zeroTrue?: boolean): value is Exclude<T, EmptyValue>;
+
+/** Checks if the value is an integer or floating-point number. @keywords isFloat, float, number, numeric, check */
+export declare function isFloat(value: any): boolean;
+
+/** Checks if the value is a callable function. @keywords isFunction, callback, function, type guard, callable */
+export declare function isFunction<T>(callback: T): callback is Extract<T, FunctionArgs<any, any>>;
+
+/** Checks if an element or selector is attached to the DOM tree. @keywords dom, attached, is connected, element in dom, is in document */
+export declare function isInDom<E extends ElementOrWindow>(element?: ElementOrString<E>): boolean;
+
+/** Checks if the element is an input field or editable. @keywords isInput, input, textarea, editable, form */
+export declare const isInput: (element: HTMLElement | EventTarget | null) => boolean;
+
+/** Checks if a value is between integers relative to a rounding step. @keywords isIntegerBetween, integer, between, range, bounds */
+export declare function isIntegerBetween(value: number, between: number): boolean;
+
+/** Checks if a keyboard event has active modifier or meta keys pressed. @keywords keyboard, event, modifier, meta, ctrl, alt, shift, cmd */
+export declare const isMetaKey: (event: KeyboardEvent) => boolean;
+
+/** Checks if a value is null or undefined. @keywords isNull, isNil, null, undefined, check */
+export declare function isNull<T>(value: T): value is Extract<T, Undefined>;
+
+/** Checks if the value is a number. @keywords isNumber, number, numeric, check, type guard */
+export declare function isNumber(value: any): value is number;
+
+/** Checks if a value is an object. @keywords isObject, object check, type guard, validation */
+export declare function isObject<T>(value: T): value is Extract<T, Record<any, any>>;
+
+/** Checks if the value is an object and not an array. @keywords isObjectNotArray, is object, not array, type guard */
+export declare function isObjectNotArray<T>(value: T): value is Exclude<Extract<T, Record<any, any>>, any[] | undefined | null>;
+
+/** Check if the device is currently online. @keywords online, network, connectivity, internet */
+export declare function isOnLine(): boolean;
+
+/** Checks if a value matches or is included within the selected value or array. @keywords is selected, check selected, match selection, contains */
+export declare function isSelected<T, S>(value: T, selected: T | T[] | S): boolean;
+
+/** Checks if all items in a list are present in the selected values. @keywords isSelectedByList, selection, contains all, match list */
+export declare function isSelectedByList<T>(values: T | T[], selected: T | T[]): boolean;
+
+/** Checks if the Web Share API is supported in the current environment. @keywords web share, navigator.share, share api, support check */
+export declare function isShare(): boolean;
+
+/** Checks if a value is of type string. @keywords isString, string, type guard, validation */
+export declare function isString<T>(value: T): value is Extract<T, string>;
+
+/** Checks if the pressed key in a keyboard event is Tab. @keywords keyboard event, tab key, keydown, keypress */
+export declare const isTab: (event: KeyboardEvent) => boolean;
+
+/** Checks if the given object is a Window instance. @keywords window, isWindow, dom, type guard */
+export declare function isWindow<E>(element: E): element is Extract<E, Window>;
+
+/** Generates a random integer within a specified range. @keywords random integer number math range */
+export declare function random(min: number, max: number): number;
+
+/** Removes the common prefix from the main string. @keywords string, prefix, remove, strip, trim */
+export declare function removeCommonPrefix(mainStr: string, prefix: string): string;
+
+/** Replaces the component name in the text with a new component name. @keywords replace component name, rename, string replace */
+export declare const replaceComponentName: (text: string | undefined, name: string, componentName: string) => string | undefined;
+
+/** Recursively replaces or merges elements of objects or arrays into the target. @keywords replace recursive, merge recursive, deep merge, object replace */
+export declare function replaceRecursive<I>(array: ObjectItem<I>, replacement?: ObjectOrArray<I>, isMerge?: boolean): ObjectItem<I>;
+
+/** Replaces placeholders in a template string with values or function returns from a map. @keywords replace template placeholder interpolation substitute */
+export declare function replaceTemplate(value: string, replaces: Record<string, string | FunctionReturn<string>>): string;
+
+/** Asynchronously resizes an image to fit within maximum dimension constraints. @keywords resize, image, scale, canvas, thumbnail, base64 */
+export declare function resizeImage(image: HTMLImageElement | string, maxSize?: number, typeData?: string): Promise<string>;
+
+type ResizeImageByMaxType = 'auto' | 'width' | 'height';
+/** Resizes an image to fit within a maximum dimension constraint. @keywords image, resize, scale, dimension, max-size */
+export declare function resizeImageByMax(image: HTMLImageElement | string, maxSize: number, type?: ResizeImageByMaxType, typeData?: string): string | undefined;
+
+/** Converts seconds into a formatted time string (e.g. HH:MM:SS or MM:SS). @keywords time, format, seconds, duration, timestamp, clock */
+export declare function secondToTime(second: number | string | undefined, hasHour?: boolean): string;
+
+/** Sets or updates a property value on a DOM element or window. @keywords set element item, update property, dom mutate */
+export declare function setElementItem<E extends ElementOrWindow, K extends keyof E, V extends E[K] = E[K]>(element: ElementOrString<E>, index: K, value: V | Record<string, V>): E | undefined;
+
+/** Modifies and updates values according to type and configuration settings. @keywords set values, update selection, multiple, maxlength */
+export declare function setValues<T>(selected: T | T[] | undefined, value: any, { multiple, maxlength, alwaysChange, notEmpty }: {
+    multiple?: boolean | undefined;
+    maxlength?: number | undefined;
+    alwaysChange?: boolean | undefined;
+    notEmpty?: boolean | undefined;
+}): T | T[] | undefined;
+
+/** Pauses execution for the specified number of milliseconds. @keywords sleep, delay, wait, pause, timeout */
+export declare function sleep(ms: number): Promise<void>;
+
+/** Sorts an array of items by column sorting specifications or a custom comparison function. @keywords sort, order, multi-column, comparator */
+export declare function sortList<T = any>(list: T[], sortColumns: SortColumnItem[], customSort?: SortFunction<T>): T[];
+
+/** Copies enumerable own properties from a source to a target object according to priority list. @keywords splice, copy, assign, merge, object */
+export declare function splice<I>(array: ObjectItem<I>, replacement?: ObjectItem<I> | I, indexStart?: string): ObjectItem<I>;
+
+/** Creates a string of the specified length filled with the given character. @keywords string fill repeat pad */
+export declare function strFill(value: string, count: number): string;
+
+/** Splits a string by separator, placing the remainder in the last element if limit is set. @keywords string, split, separator, limit */
+export declare function strSplit(value: number | string, separator: string, limit?: number): string[];
+
+/** Converts a value to an array, returning it as is if already an array or wrapping it in an array. @keywords toArray, cast array, wrap array, normalize array */
+export declare function toArray<T>(value: T): T extends any[] ? T : [T];
+
+/** Converts a string to upper camel case (PascalCase). @keywords camelCase, pascalCase, string conversion, casing */
+export declare function toCamelCase(value: string): string;
+
+/** Converts a string to PascalCase (CamelCase with capitalized first letter). @keywords camelCase pascalCase string transform format */
+export declare function toCamelCaseFirst(value: string): string;
+
+/** Converts a Date, timestamp, or date string into a Date object. @keywords date, parse date, to date, convert date */
+export declare function toDate<T extends Date | number | string>(value?: T): (T & Date) | Date;
+
+/** Converts a string to kebab-case format by lowercasing letters and replacing delimiters with hyphens. @keywords kebab-case, slugify, string, transform, dashes */
+export declare function toKebabCase(value: string): string;
+
+/**
+ * Converts a string or number to a finite floating-point number, handling various separators and stripping non-numeric characters.
+ * @keywords toNumber, parse float, string to number, sanitize number, numeric conversion
+ * @example
+ * toNumber("1 234,56") // 1234.56
+ * toNumber("1,234.56") // 1234.56
+ * toNumber("1,234")    // 1.234
+ */
+export declare function toNumber(value?: NumberOrString): number;
+
+/** Converts a value to a number clamped to a maximum allowed value, with optional locale formatting. @keywords toNumberByMax, clamp, max, number conversion, formatting */
+export declare function toNumberByMax(value: string | number, max?: string | number, formatting?: boolean, language?: string): string | number;
+
+/** Converts a value to a positive finite number (> 0), or returns a default fallback value. @keywords positive number, parse number, finite number, toNumberPositive */
+export declare function toNumberPositive(value?: number | string | null, defaultValue?: number): number;
+
+/** Converts a value to a percentage relative to a maximum value. @keywords percentage, percent, ratio, calculate, convert */
+export declare function toPercent(maxValue: number, value: number): number;
+
+/** Converts a value to a percentage scaled by 100 relative to a maximum value. @keywords percent, percentage, ratio, scale, math */
+export declare function toPercentBy100(maxValue: number, value: number): number;
+
+/** Converts a value to a string, returning an empty string for null or undefined. @keywords stringify, convert, format, serialize */
+export declare function toString<T>(value: T): string;
+
+/** Transforms a string into its corresponding data type (`undefined`, `null`, boolean, object, number, or function). @keywords transform parse convert cast deserialize @param isFunction Flag to check for function in global window object */
+export declare function transformation(value: any, isFunction?: boolean): any;
+
+/** Converts a Uint8Array to a base64-encoded string. @keywords base64, uint8array, encode, binary, string */
+export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
+
+/** Removes duplicate elements from an array. @keywords unique, deduplicate, distinct, array, filter */
+export declare function uniqueArray<T>(value: T[]): T[];
+
+/** Writes text data to the system clipboard. @keywords clipboard, copy, write, buffer */
+export declare function writeClipboardData(text: string): Promise<void>;
+
+/** Default list of predefined error causes and messages for ErrorCenter. @keywords error_causes error_list error_center */
+export declare const errorCauseList: ErrorCenterCauseList;
+
+/** HTTP methods for API requests @keywords http method get post put patch delete */
+export declare enum ApiMethodItem {
+    delete = "DELETE",
+    get = "GET",
+    post = "POST",
+    put = "PUT",
+    patch = "PATCH"
+}
+/** Cached API response entry @keywords cache store item */
+export type ApiCacheItem<T = any> = {
+    value: T;
+    age?: number;
+    cacheAge: number;
+};
+export type ApiCacheList = Record<string, ApiCacheItem>;
+/** Global API client configuration options @keywords api config options fetch */
+export type ApiConfig = {
+    urlRoot?: string;
+    origin?: string;
+    headers?: ApiHeadersValue;
+    requestDefault?: ApiDefaultValue;
+    preparation?: (apiFetch: ApiFetch) => Promise<void>;
+    end?: (query: Response, apiFetch: ApiFetch) => Promise<ApiPreparationEnd>;
+    timeout?: number;
+    devMode?: boolean;
+    wrapper?: <R>(callback: () => Promise<R>, apiFetch: ApiFetch) => Promise<R>;
+};
+export type ApiData<T = any> = T extends any[] ? T : ApiDataItem<T>;
+/** API response validation result structure @keywords validation response status */
+export type ApiDataValidation = {
+    status?: ApiStatusType;
+    code?: string | number;
+    message?: string;
+    error?: {
+        code?: string | number;
+        message?: string;
+    };
+};
+/** API response payload and metadata wrapper @keywords response payload data */
+export type ApiDataItem<T = any> = T & ApiDataValidation & {
+    data?: T;
+    success?: boolean;
+    statusObject?: ApiStatusItem;
+    errorObject?: ApiErrorItem;
+};
+export type ApiHeadersValue = Record<string, string> | (() => Record<string, string>);
+export type ApiDefaultValue = Record<string, any> | (() => Record<string, any>);
+/** API request execution options and parameters @keywords fetch request options query */
+export type ApiFetch = {
+    api?: boolean;
+    path?: string;
+    pathFull?: string;
+    method?: ApiMethod;
+    request?: FormData | Record<string, any> | string;
+    auth?: boolean;
+    headers?: Record<string, string> | null;
+    type?: string;
+    toData?: boolean;
+    global?: boolean;
+    devMode?: boolean;
+    hideError?: boolean;
+    hideLoading?: boolean;
+    retry?: number;
+    retryDelay?: number;
+    queryReturn?: (query: Response) => Promise<any | ApiDataValidation>;
+    globalPreparation?: boolean;
+    globalEnd?: boolean;
+    init?: RequestInit;
+    initError?: boolean;
+    timeout?: number;
+    controller?: AbortController;
+    cache?: number;
+    enableClientCache?: boolean;
+    cacheId?: number | string;
+    endResetLimit?: number;
+    wrapper?: <R>(callback: () => Promise<R>, apiFetch: ApiFetch) => Promise<R>;
+};
+/** Preloaded hydration data for API response matching @keywords hydration preload ssr */
+export type ApiHydrationItem = {
+    path: string;
+    method: ApiMethod;
+    request?: ApiFetch['request'];
+    response: any;
+};
+export type ApiHydrationList = ApiHydrationItem[];
+/** API error mapping and interception configuration @keywords error storage interceptor */
+export type ApiErrorStorageItem = Record<string, any> & {
+    url: string | RegExp;
+    method: ApiMethodItem;
+    code?: string;
+    status?: number;
+    validation?: (response: Response) => boolean;
+    message?: string | ((response?: Response) => string);
+};
+export type ApiErrorStorageList = ApiErrorStorageItem[];
+export type ApiMethod = string | ApiMethodItem;
+/** Global preparation and teardown hook execution result @keywords hook lifecycle reset */
+export type ApiPreparationEnd = {
+    reset?: boolean;
+    data?: any;
+};
+/** Mock API response descriptor and matching rules @keywords mock response stub */
+export type ApiResponseItem = {
+    path: string | RegExp;
+    method: ApiMethod;
+    request?: ApiFetch['request'] | '*any';
+    response: any | ((request?: ApiFetch['request']) => any);
+    disable?: any;
+    isForGlobal?: boolean;
+    lag?: any;
+};
+/** API request status and error tracking descriptor @keywords status tracker state */
+export type ApiStatusItem = {
+    status?: number;
+    statusText?: string;
+    error?: string;
+    lastResponse?: any;
+    lastStatus?: ApiStatusType;
+    lastCode?: string;
+    lastMessage?: string;
+};
+export type ApiStatusType = 'success' | 'error' | 'warning' | 'info';
+
+export type Undefined = undefined | null;
+/** Union of nullish, falsy values and their string representations. @keywords empty, falsy, nullish */
+export type EmptyValue = Undefined | 0 | false | '' | 'undefined' | 'null' | '0' | 'false' | '[]';
+export type NumberOrString = number | string;
+export type NumberOrStringOrBoolean = number | string | boolean;
+export type NumberOrStringOrDate = NumberOrString | Date;
+export type NormalOrArray<T = NumberOrString> = T | T[];
+export type NormalOrPromise<T> = T | Promise<T>;
+export type ObjectItem<T = any> = Record<string, T>;
+export type ObjectOrArray<T = any> = T[] | ObjectItem<T>;
+/** Extracts item type from an array or returns the type itself. @keywords array, item, unwrap */
+export type ArrayToItem<T> = T extends any[] ? T[number] : T;
+export type FunctionReturn<R = any> = () => R;
+export type FunctionVoid = () => void;
+export type FunctionArgs<T, R> = (...args: T[]) => R;
+export type FunctionAnyType<T = any, R = any> = (...args: T[]) => R;
+export type ItemList<T = any> = Record<string, T>;
+export type Item<V> = {
+  index: string;
+  value: V;
+};
+export type ItemValue<V> = {
+  label: string;
+  value: V;
+};
+export type ItemName<V> = {
+  name: string | number;
+  value: V;
+};
+export type ElementOrWindow = HTMLElement | Window;
+export type ElementOrString<E extends ElementOrWindow> = E | string;
+export type EventOptions = AddEventListenerOptions | boolean | undefined;
+/** Event listener callback with optional detail payload. @keywords event, listener, detail */
+export type EventListenerDetail<O extends Event, D extends Record<string, any>> = (event: O, detail?: D) => void;
+/** Tracks active DOM event listeners and ResizeObservers. @keywords event, listener, observer, activity */
+export type EventActivityItem<E extends ElementOrWindow> = {
+  element: E | undefined;
+  type: string;
+  listener?: (event: any | Event) => void;
+  observer?: ResizeObserver;
+};
+export type ImageCoordinator = {
+  x: number;
+  y: number;
+};
+
+export type ErrorCenterGroup = string | undefined;
+
+/** Error item descriptor with metadata and custom payload details. @keywords error cause item */
+export type ErrorCenterCauseItem<D = any> = {
+  group?: ErrorCenterGroup;
+  code: string;
+  priority?: number;
+  label?: string;
+  message?: string;
+  details?: D;
+};
+
+export type ErrorCenterCauseList = ErrorCenterCauseItem[];
+
+/** Callback function for processing error items. @keywords error handler callback */
+export type ErrorCenterHandlerCallback = (cause: ErrorCenterCauseItem) => void;
+
+/** Error handler registration entry mapped to an optional error group. @keywords error handler item */
+export type ErrorCenterHandlerItem = {
+  group?: ErrorCenterGroup;
+  handlers: ErrorCenterHandlerCallback[];
+};
+
+export type ErrorCenterHandlerList = ErrorCenterHandlerItem[];
+
+/** Predicate determining whether an error should be logged to the console. @keywords error console filter */
+export type ErrorCenterHandlerIsConsoleCallback = (cause: ErrorCenterCauseItem) => boolean;
+
+/** Console logging configuration flag or dynamic predicate. @keywords error console logging */
+export type ErrorCenterHandlerIsConsole = boolean | ErrorCenterHandlerIsConsoleCallback;
+
+/** Supported formatter types. @keywords formatter, types, formatting */
+export declare enum FormattersType {
+    currency = "currency",
+    date = "date",
+    name = "name",
+    number = "number",
+    plural = "plural",
+    unit = "unit"
+}
+export type FormattersOptionsCurrency = {
+    currencyPropName?: string;
+    options?: string | Intl.NumberFormatOptions;
+    numberOnly?: boolean;
+};
+export type FormattersOptionsDate = {
+    type?: GeoDate;
+    options?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions;
+    hour24?: boolean;
+};
+export type FormattersOptionsName = {
+    lastPropName?: string;
+    firstPropName?: string;
+    surname?: string;
+    short?: boolean;
+};
+export type FormattersOptionsNumber = {
+    options?: Intl.NumberFormatOptions;
+};
+export type FormattersOptionsPlural = {
+    words: string;
+    options?: Intl.PluralRulesOptions;
+    optionsNumber?: Intl.NumberFormatOptions;
+};
+export type FormattersOptionsUnit = {
+    unit: string | Intl.NumberFormatOptions;
+};
+/** Resolves option configuration type based on formatter type. @keywords options, type mapping */
+export type FormattersOptionsInformation<Type extends FormattersType> = Type extends FormattersType.currency ? FormattersOptionsCurrency : Type extends FormattersType.date ? FormattersOptionsDate : Type extends FormattersType.name ? FormattersOptionsName : Type extends FormattersType.number ? FormattersOptionsNumber : Type extends FormattersType.plural ? FormattersOptionsPlural : Type extends FormattersType.unit ? FormattersOptionsUnit : Record<string, any>;
+/** Single property formatter configuration. @keywords formatter, item, configuration */
+export type FormattersOptionsItem<Type extends FormattersType = FormattersType, R = string> = {
+    type?: Type;
+    transformation?: (valueOriginal: any, item: any, options?: FormattersOptionsInformation<Type>) => R;
+    options?: FormattersOptionsInformation<Type>;
+};
+export type FormattersOptionsList = Record<string, FormattersOptionsItem>;
+export type FormattersListItem = Record<string, any>;
+export type FormattersList<Item extends FormattersListItem> = Item[];
+/** Capitalizes dot-notated property paths into camelCase. @keywords capitalize, path, utility */
+export type FormattersCapitalize<K extends string> = K extends `${infer First}.${infer Rest}` ? `${First}${Capitalize<FormattersCapitalize<Rest>>}` : K;
+export type FormattersColumns<T extends FormattersOptionsList> = (keyof T & string)[];
+export type FormattersKey<K, A extends string = 'Format'> = K extends string ? `${FormattersCapitalize<K>}${A}` : never;
+/** Appends formatted string properties to an item type. @keywords data item, format */
+export type FormattersDataItem<T extends FormattersListItem, KT extends string[]> = {
+    [K in keyof T | FormattersKey<KT[number]>]: K extends keyof T ? T[K] : string;
+};
+export type FormattersListFormat<T extends FormattersListItem, K extends string[]> = FormattersDataItem<T, K>[];
+export type FormattersListColumnItem<T extends FormattersListItem, O extends FormattersOptionsList> = FormattersDataItem<T, FormattersColumns<O>>;
+export type FormattersListColumns<T extends FormattersListItem, O extends FormattersOptionsList> = FormattersListFormat<T, FormattersColumns<O>>;
+export type FormattersListProp = FormattersList<FormattersListItem> | FormattersListItem;
+export type FormattersItemProp<List extends FormattersListProp> = ArrayToItem<List>;
+/** Resulting formatted list or item preserving input collection shape. @keywords return type, formatters */
+export type FormattersReturn<List extends FormattersListProp, Options extends FormattersOptionsList = FormattersOptionsList, Item extends FormattersItemProp<List> = FormattersItemProp<List>> = List extends any[] ? FormattersListColumns<Item, Options> : (FormattersListColumnItem<Item, Options> | undefined);
+
+export type GeoDate = 'full' | 'datetime' | 'date' | 'year-month' | 'year' | 'month' | 'day' | 'day-month' | 'time' | 'hour-minute' | 'hour' | 'minute' | 'second';
+export type GeoFirstDay = 1 | 6 | 0;
+export type GeoHours = '12' | '24';
+export type GeoTimeZoneStyle = 'minute' | 'hour' | 'ISO8601' | 'RFC';
+
+/** Geographic configuration item containing country, language, and locale formatting rules @keywords geo, locale, country, language */
+export interface GeoItem {
+  country: string;
+  countryAlternative?: string[];
+  language: string;
+  languageAlternative?: string[];
+  firstDay?: string | null;
+  zone?: string | null;
+  phoneCode?: string;
+  phoneWithin?: string;
+  phoneMask?: string | string[];
+  nameFormat?: 'fl' | 'fsl' | 'lf' | 'lsf' | string;
+  unit?: {
+    'millimeter'?: string;
+    'centimeter'?: string;
+    'meter'?: string;
+    'kilometer'?: string;
+    'square-meter'?: string;
+    'hectare'?: string;
+    'gram'?: string;
+    'kilogram'?: string;
+    'tonne'?: string;
+    'milliliter'?: string;
+    'liter'?: string;
+    'celsius'?: string;
+    'kilometer-per-hour'?: string;
+  };
+}
+
+/** Extended geographic item with resolved required locale fields @keywords geo, locale, full */
+export interface GeoItemFull extends Omit<GeoItem, 'firstDay'> {
+  standard: string;
+  firstDay: string;
+  location: string;
+  locationCountry: string;
+  locationLanguage: string;
+}
+
+/** Geographic flag and country display metadata @keywords flag, country, language */
+export interface GeoFlagItem {
+  language: string;
+  languageCode: string;
+  country: string;
+  countryCode: string;
+  standard: string;
+  icon?: string;
+  label: string;
+  value: string;
+  phoneCode?: string;
+}
+
+/** Geographic flag item with localized native language descriptions @keywords flag, national, localized */
+export interface GeoFlagNational extends GeoFlagItem {
+  description: string;
+  nationalLanguage: string;
+  nationalCountry: string;
+}
+
+/** Country phone prefix and mask pattern metadata @keywords phone, mask, countryCode */
+export interface GeoPhoneValue {
+  phone: number;
+  within: number;
+  mask: string[];
+  value: string;
+}
+
+/** Prefix tree node for phone code lookup and mask formatting @keywords phone, trie, prefix, mask */
+export interface GeoPhoneMap {
+  items: GeoPhoneValue[];
+  info: GeoPhoneValue | undefined;
+  value: string | undefined;
+  mask: string[];
+  maskFull: string[];
+  next: Record<string, GeoPhoneMap>;
+}
+
+/** Result of a phone number lookup against the prefix tree @keywords phone, lookup, result */
+export interface GeoPhoneMapInfo {
+  item?: GeoPhoneMap;
+  phone?: string;
+}
+
+export declare enum MetaTag {
+    title = "title",
+    description = "description",
+    keywords = "keywords",
+    canonical = "canonical",
+    robots = "robots",
+    author = "author"
+}
+export declare enum MetaRobots {
+    indexFollow = "index, follow",
+    noIndexFollow = "noindex, follow",
+    indexNoFollow = "index, nofollow",
+    noIndexNoFollow = "noindex, nofollow",
+    noArchive = "noarchive",
+    noSnippet = "nosnippet",
+    noImageIndex = "noimageindex",
+    images = "images",
+    noTranslate = "notranslate",
+    noPreview = "nopreview",
+    textOnly = "textonly",
+    noIndexSubpages = "noindex, noarchive",
+    none = "none"
+}
+export declare enum MetaOpenGraphTag {
+    title = "og:title",
+    type = "og:type",
+    url = "og:url",
+    image = "og:image",
+    description = "og:description",
+    locale = "og:locale",
+    siteName = "og:site_name",
+    localeAlternate = "og:locale:alternate",
+    imageUrl = "og:image:url",
+    imageSecureUrl = "og:image:secure_url",
+    imageType = "og:image:type",
+    imageWidth = "og:image:width",
+    imageHeight = "og:image:height",
+    imageAlt = "og:image:alt",
+    video = "og:video",
+    videoUrl = "og:video:url",
+    videoSecureUrl = "og:video:secure_url",
+    videoType = "og:video:type",
+    videoWidth = "og:video:width",
+    videoHeight = "og:video:height",
+    audio = "og:audio",
+    audioSecureUrl = "og:audio:secure_url",
+    audioType = "og:audio:type",
+    articlePublishedTime = "article:published_time",
+    articleModifiedTime = "article:modified_time",
+    articleExpirationTime = "article:expiration_time",
+    articleAuthor = "article:author",
+    articleSection = "article:section",
+    articleTag = "article:tag",
+    bookAuthor = "book:author",
+    bookIsbn = "book:isbn",
+    bookReleaseDate = "book:release_date",
+    bookTag = "book:tag",
+    musicDuration = "music:duration",
+    musicAlbum = "music:album",
+    musicAlbumDisc = "music:album:disc",
+    musicAlbumTrack = "music:album:track",
+    musicMusician = "music:musician",
+    musicSong = "music:song",
+    musicSongDisc = "music:song:disc",
+    musicSongTrack = "music:song:track",
+    musicReleaseDate = "music:release_date",
+    musicCreator = "music:creator",
+    videoActor = "video:actor",
+    videoActorRole = "video:actor:role",
+    videoDirector = "video:director",
+    videoWriter = "video:writer",
+    videoDuration = "video:duration",
+    videoReleaseDate = "video:release_date",
+    videoTag = "video:tag",
+    videoSeries = "video:series",
+    profileFirstName = "profile:first_name",
+    profileLastName = "profile:last_name",
+    profileUsername = "profile:username",
+    profileGender = "profile:gender",
+    productBrand = "product:brand",
+    productAvailability = "product:availability",
+    productCondition = "product:condition",
+    productPriceAmount = "product:price:amount",
+    productPriceCurrency = "product:price:currency",
+    productRetailerItemId = "product:retailer_item_id",
+    productCategory = "product:category",
+    productEan = "product:ean",
+    productIsbn = "product:isbn",
+    productMfrPartNo = "product:mfr_part_no",
+    productUpc = "product:upc",
+    productWeightValue = "product:weight:value",
+    productWeightUnits = "product:weight:units",
+    productColor = "product:color",
+    productMaterial = "product:material",
+    productPattern = "product:pattern",
+    productAgeGroup = "product:age_group",
+    productGender = "product:gender"
+}
+export declare enum MetaOpenGraphType {
+    website = "website",
+    article = "article",
+    video = "video.other",
+    videoTvShow = "video.tv_show",
+    videoEpisode = "video.episode",
+    videoMovie = "video.movie",
+    musicAlbum = "music.album",
+    musicPlaylist = "music.playlist",
+    musicSong = "music.song",
+    musicRadioStation = "music.radio_station",
+    app = "app",
+    product = "product",
+    business = "business.business",
+    place = "place",
+    event = "event",
+    profile = "profile",
+    book = "book"
+}
+export declare enum MetaOpenGraphAvailability {
+    inStock = "in stock",
+    outOfStock = "out of stock",
+    preorder = "preorder",
+    backorder = "backorder",
+    discontinued = "discontinued",
+    pending = "pending"
+}
+export declare enum MetaOpenGraphCondition {
+    new = "new",
+    used = "used",
+    refurbished = "refurbished"
+}
+export declare enum MetaOpenGraphAge {
+    newborn = "newborn",
+    infant = "infant",
+    toddler = "toddler",
+    kids = "kids",
+    adult = "adult"
+}
+export declare enum MetaOpenGraphGender {
+    female = "female",
+    male = "male",
+    unisex = "unisex"
+}
+export declare enum MetaTwitterTag {
+    card = "twitter:card",
+    site = "twitter:site",
+    creator = "twitter:creator",
+    url = "twitter:url",
+    title = "twitter:title",
+    description = "twitter:description",
+    image = "twitter:image",
+    imageAlt = "twitter:image:alt",
+    imageSrc = "twitter:image:src",
+    imageWidth = "twitter:image:width",
+    imageHeight = "twitter:image:height",
+    label1 = "twitter:label1",
+    data1 = "twitter:data1",
+    label2 = "twitter:label2",
+    data2 = "twitter:data2",
+    appNameIphone = "twitter:app:name:iphone",
+    appIdIphone = "twitter:app:id:iphone",
+    appUrlIphone = "twitter:app:url:iphone",
+    appNameIpad = "twitter:app:name:ipad",
+    appIdIpad = "twitter:app:id:ipad",
+    appUrlIpad = "twitter:app:url:ipad",
+    appNameGooglePlay = "twitter:app:name:googleplay",
+    appIdGooglePlay = "twitter:app:id:googleplay",
+    appUrlGooglePlay = "twitter:app:url:googleplay",
+    player = "twitter:player",
+    playerWidth = "twitter:player:width",
+    playerHeight = "twitter:player:height",
+    playerStream = "twitter:player:stream",
+    playerStreamContentType = "twitter:player:stream:content_type"
+}
+export declare enum MetaTwitterCard {
+    summary = "summary",
+    summaryLargeImage = "summary_large_image",
+    app = "app",
+    player = "player",
+    product = "product",
+    gallery = "gallery",
+    photo = "photo",
+    leadGeneration = "lead_generation",
+    audio = "audio",
+    poll = "poll"
+}
+
+export type SearchItem = Record<string, any>;
+export type SearchColumnPath<K, P> = K extends string ? P extends string ? `${K}.${P}` : never : never;
+/** Resolves flat and nested dot-notated property paths for an item. @keywords search column path */
+export type SearchColumn<T extends SearchItem> = {
+    [K in keyof T]-?: NonNullable<T[K]> extends object ? K | SearchColumnPath<K, keyof NonNullable<T[K]>> : K;
+}[keyof T];
+export type SearchColumns<T extends SearchItem> = (SearchColumn<T> & string)[];
+export type SearchFormatCapitalize<K extends string> = K extends `${infer First}.${infer Rest}` ? `${First}${Capitalize<SearchFormatCapitalize<Rest>>}` : K;
+export type SearchFormatKey<K> = K extends string ? `${SearchFormatCapitalize<K>}Search` : never;
+/** Formats search item with search keys and active status. @keywords search format item */
+export type SearchFormatItem<T extends SearchItem, KT extends string[]> = {
+    [K in keyof T | SearchFormatKey<KT[number]>]: K extends keyof T ? T[K] : string;
+} & {
+    searchActive?: boolean;
+};
+export type SearchFormatList<T extends SearchItem, K extends string[]> = SearchFormatItem<T, K>[];
+export type SearchListValue<T extends SearchItem> = T[] | undefined;
+/** Search configuration options. @keywords search options config */
+export type SearchOptions = {
+    limit?: number;
+    returnEverything?: boolean;
+    delay?: number;
+    findExactMatch?: boolean;
+    classSearchName?: string;
+};
+export type SearchCacheItem<T extends SearchItem> = {
+    item: T;
+    value: string;
+};
+export type SearchCache<T extends SearchItem> = SearchCacheItem<T>[];
+export type HighlightMatchItem = {
+    text: string;
+    isMatch: boolean;
+};
+
+export type SortDir = 'asc' | 'desc';
+export type SortColumnItem = {
+    column?: string;
+    dir?: SortDir;
+};
+/** Custom comparison function for sorting items. @keywords sort, comparator, order */
+export type SortFunction<T = any> = (a: T, b: T, column?: string, dir?: SortDir) => number;
+
+/** Translation plugin configuration options @keywords i18n, translate, config, options */
+export type TranslateConfig = {
+    url?: string;
+    propsName?: string;
+    readApi?: boolean;
+};
+/** Translation code or list of translation codes @keywords i18n, key, code */
+export type TranslateCode = string | string[];
+/** Map of translation keys to resolved translated strings @keywords i18n, list, dictionary */
+export type TranslateList<T extends TranslateCode[]> = {
+    [K in T[number] as K extends readonly string[] ? K[0] : K]: string;
+};
+/** Conditional translation result resolving to an object for multiple keys or a string for single key @keywords i18n, translate, resolver */
+export type TranslateItemOrList<T extends TranslateCode> = T extends string[] ? TranslateList<T> : string;
+export type TranslateDataFileList = Record<string, string>;
+/** Asynchronous loader function for translation data @keywords i18n, loader, async */
+export type TranslateDataFileItem = () => Promise<TranslateDataFileList>;
+/** Mapping of locale identifiers to translation file loaders @keywords i18n, locale, dictionary */
+export type TranslateDataFile = Record<string, TranslateDataFileItem>;
+/** Prefix identifier for global translations @keywords i18n, global, prefix */
+export declare const TRANSLATE_GLOBAL_PREFIX = "global";
+/** Batch loading request timeout in milliseconds @keywords i18n, timeout, batch */
+export declare const TRANSLATE_TIME_OUT = 160;