@dxtmisha/functional-basic 1.11.2 → 2.0.0

package/ai-types.md

@@ -1,111 +1,117 @@
-All these methods are in the @dxtmisha/functional-basic (v1.11.2) library.
+All these methods are in the @dxtmisha/functional-basic (v2.0.0) library.
 
 ```typescript
-/** Class for managing HTTP requests and global API configuration. @keywords api, http, request, fetch */
+/** HTTP client manager for making requests and configuring API settings. @keywords http, client, api, request, fetch */
 export declare class Api {
-    /** Checks if the current server environment is running on localhost. @keywords localhost, environment, check */
+    /** Checks whether the server environment is running on localhost. @keywords localhost, environment, server, check */
     static isLocalhost(): boolean;
-    /** Returns the singleton instance of the ApiInstance class. @keywords singleton, instance */
+    /** Returns the singleton ApiInstance. @keywords instance, singleton, api */
     static getItem(): ApiInstance;
-    /** Returns the status handler for the last executed request. @keywords status, response_status */
+    /** Retrieves the status handler of the last executed request. @keywords status, response, state */
     static getStatus(): ApiStatus;
-    /** Returns the response processor and handler instance. @keywords response, handler */
+    /** Retrieves the API response handler instance. @keywords response, handler */
     static getResponse(): ApiResponse;
-    /** Returns the API hydration handler. @keywords hydration, ssr */
+    /** Retrieves the hydration handler instance. @keywords hydration, state, ssr */
     static getHydration(): ApiHydration;
-    /** Returns a serialized HTML script tag containing client hydration data. @keywords hydration_script, ssr, script */
+    /** Generates an HTML script element string containing hydration data. @keywords hydration, script, ssr, html */
     static getHydrationScript(): string;
-    /** Returns the base origin URL combined with the API path. @keywords origin, base_url, endpoint */
+    /** Retrieves 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 */
+    /** Resolves the complete URL for a request path. @keywords url, path, resolve, endpoint */
     static getUrl(path: string, api?: boolean): string;
-    /** Formats and retrieves request body data for non-GET requests. @keywords body, payload, form_data */
+    /** Formats the payload into an appropriate HTTP request body. @keywords body, payload, formdata, request */
     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 */
+    /** Generates a query string URL for GET requests. @keywords query, query-string, get, params */
     static getBodyForGet(request: ApiFetch['request'], path?: string, method?: ApiMethodItem): string;
-    /** Updates default global HTTP request headers. @keywords headers, default_headers, config */
+    /** Sets default request headers. @keywords headers, config, default */
     static setHeaders(headers: ApiHeadersValue): void;
-    /** Sets default request parameter values. @keywords defaults, request_defaults */
+    /** Sets default request payload data. @keywords default, payload, request */
     static setRequestDefault(request: ApiDefaultValue): void;
-    /** Sets the default base script URL path. @keywords base_url, path, endpoint */
+    /** Sets the base API path URL. @keywords url, base-path, config */
     static setUrl(url: string): void;
-    /** Sets a hook callback to be executed before executing requests. @keywords preparation, interceptor, pre_request */
+    /** Sets an interceptor callback executed before each request. @keywords middleware, interceptor, preparation, 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 */
+    /** Sets an interceptor callback executed after each request. @keywords middleware, interceptor, post-request, response */
     static setEnd(callback: (query: Response, apiFetch: ApiFetch) => Promise<ApiPreparationEnd>): void;
-    /** Sets global request timeout in milliseconds. @keywords timeout, request_timeout */
+    /** Sets the global request timeout duration in milliseconds. @keywords timeout, duration, abort */
     static setTimeout(timeout: number): void;
-    /** Sets the base origin protocol and domain. @keywords origin, domain, host */
+    /** Sets the default origin protocol and domain. @keywords origin, host, domain */
     static setOrigin(origin: string): void;
-    /** Sets a custom execution wrapper around requests. @keywords wrapper, middleware, interceptor */
+    /** Sets a higher-order wrapper function around API requests. @keywords wrapper, interceptor, proxy */
     static setWrapper(wrapper: <R>(callback: () => Promise<R>, apiFetch: ApiFetch) => Promise<R>): void;
-    /** Applies multiple API configuration options at once. @keywords config, options, setup */
+    /** Applies multiple global API configuration settings. @keywords config, options, setup */
     static setConfig(config?: ApiConfig): void;
-    /** Executes an HTTP request using a path string or request config. @keywords request, http, fetch */
+    /** Executes an HTTP request using a path string or configuration object. @keywords request, execute, http */
     static request<T>(pathRequest: string | ApiFetch): Promise<T>;
-    /** Sends a GET HTTP request. @keywords get, fetch */
+    /** Executes an HTTP GET request. @keywords get, http, fetch */
     static get<T>(request: ApiFetch): Promise<T>;
-    /** Sends a POST HTTP request. @keywords post, fetch */
+    /** Executes an HTTP POST request. @keywords post, http, fetch */
     static post<T>(request: ApiFetch): Promise<T>;
-    /** Sends a PUT HTTP request. @keywords put, fetch */
+    /** Executes an HTTP PUT request. @keywords put, http, fetch */
     static put<T>(request: ApiFetch): Promise<T>;
-    /** Sends a PATCH HTTP request. @keywords patch, fetch */
+    /** Executes an HTTP PATCH request. @keywords patch, http, fetch */
     static patch<T>(request: ApiFetch): Promise<T>;
-    /** Sends a DELETE HTTP request. @keywords delete, fetch */
+    /** Executes an HTTP DELETE request. @keywords delete, http, fetch */
     static delete<T>(request: ApiFetch): Promise<T>;
 }
 
-/** 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 */
+/** Manages inter-context communication via BroadcastChannel API. @keywords broadcast channel, messaging, cross-tab, ipc */
+export declare class BroadcastMessage<Message = unknown> {
+    /** Initializes the broadcast channel with optional message/error handlers. @keywords broadcast, channel, init, listener */
     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 */
+    /** Returns the active BroadcastChannel instance if available in the environment. @keywords channel instance, dom, get */
     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 */
+    /** Sets the callback executed when a message is received. @keywords onmessage, listener, handler, callback */
     setCallback(callback: (event: MessageEvent<Message>) => void): this;
-    /** Sets the message error callback handler. @keywords onmessageerror, error handler */
+    /** Sets the callback executed on message errors. @keywords messageerror, error handler, callback */
     setCallbackError(callbackError: (event: MessageEvent<Message>) => void): this;
-    /** Closes the broadcast channel and stops listening for messages. @keywords destroy, close, cleanup */
+    /** Sends a message to all listening contexts on the channel. @keywords send, postMessage, emit, publish */
+    post(message: Message): this;
+    /** Closes the channel and stops listening for messages. @keywords close, cleanup, unbind, destroy */
     destroy(): this;
 }
 
-/** In-memory key-value cache with dependency-based invalidation. @keywords cache, memoize, storage, in-memory */
+/** In-memory cache storing computed values by key. @warning Obsolete and should not be used. @keywords in-memory cache, memoize, key-value */
 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>;
+    /** Retrieves or computes and caches a synchronous value by key with optional dependency invalidation. @keywords cache get, memoize, sync cache */
+    get<T>(name: string, callback: () => T, comparison?: unknown[]): T;
+    /** Asynchronously retrieves or computes and caches a value by key with optional dependency invalidation. @keywords async cache, memoize promise, async get */
+    getAsync<T>(name: string, callback: () => T, comparison?: unknown[]): 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;
+/** Resolves the return type of Cookie.get based on generic type and default fallback. @keywords cookie, return type, fallback */
+export type CookieGet<T, D = undefined> = [D] extends [undefined] ? (T | undefined) : unknown extends T ? (D extends () => infer R ? R : D) : (T | (D extends () => infer R ? R : D));
+/** Cookie manager for reading, writing, and deleting browser cookies. @keywords cookie, storage, browser */
+export declare class Cookie<T = unknown> {
+  /** Initializes a Cookie instance for the specified cookie name. @keywords cookie, init, constructor */
+  constructor(name: string);
+  /** Retrieves a Cookie instance by the specified cookie name. @keywords cookie, getInstance, factory */
+  static getInstance<T = unknown>(name: string): Cookie<T>;
+  /** Retrieves the cookie value or sets and returns a default value if not set. @keywords cookie, get, read, fallback */
+  get<D extends T | string | (() => (T | string)) | undefined = undefined>(defaultValue?: D, options?: CookieOptions): CookieGet<T, D>;
+  /** Updates the cookie value with optional configuration parameters. @keywords cookie, set, write, update */
+  set(value?: T | string | (() => (T | string)), options?: CookieOptions): void;
+  /** Deletes the cookie. @keywords cookie, remove, delete, clear */
+  remove(): void;
 }
 
-/** Manages cookie access block status. @keywords cookie, block, access */
+/** Manages cookie access and blocking status. @keywords cookie, block, access, permissions */
 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 */
+    /** Retrieves current cookie blocking status. @keywords cookie, block, status, check */
     static get(): boolean;
-    /** Sets the cookie block status. @keywords cookie, block, status, set */
+    /** Sets cookie blocking status. @keywords cookie, block, status, toggle */
     static set(value: boolean): void;
+    /** Gets request-isolated CookieBlockInstance. @keywords cookie, block, instance, request */
+    static getItem(): CookieBlockInstance;
 }
 
-export type CookieSameSite = 'strict' | 'lax';
-
-/** Options for setting and configuring cookies. @keywords cookie, options, samesite, secure */
+export type CookieSameSite = 'strict' | 'lax' | 'none';
+/** Resolves return type of CookieStorage.get based on fallback value. @keywords cookie return type */
+export type CookieStorageGet<T, D = undefined> = [
+    D
+] extends [
+    undefined
+] ? (T | undefined) : unknown extends T ? (D extends () => infer R ? R : D) : T;
 export type CookieOptions = {
     age?: number;
     sameSite?: CookieSameSite;
@@ -114,870 +120,982 @@ export type CookieOptions = {
     secure?: boolean;
     httpOnly?: boolean;
     partitioned?: boolean;
-    arguments?: string[] | Record<string, string | number | boolean>;
+    arguments?: string[] | Record<string, unknown>;
 };
-
-/** Manages cookie storage with custom listeners across DOM and SSR environments. @keywords cookie, storage, ssr, browser, persistence */
+/** Manages cookies with support for DOM, SSR, and custom storage listeners. @keywords cookie storage ssr browser */
 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 */
+    /** Retrieves a cookie value or returns the default fallback. @keywords cookie get read storage */
+    static get<T = unknown, D extends T | (() => T) | undefined = undefined>(name: string, defaultValue?: D, options?: CookieOptions): CookieStorageGet<T, D>;
+    /** Writes a cookie value with optional attributes. @keywords cookie set save write */
+    static set<T = unknown>(name: string, value: T | (() => T), options?: CookieOptions): T;
+    /** Deletes a cookie from storage. @keywords cookie remove delete */
+    static remove(name: string, options?: CookieOptions): void;
+    /** Synchronizes and updates cache from current cookie sources. @keywords cookie update refresh sync */
     static update(): void;
+    /** Clears in-memory items and resets listeners to default state. @keywords cookie reset clear */
+    static reset(): void;
+    /**
+     * Initializes storage listeners and hooks for custom or SSR runtimes.
+     * @remarks When omitted, DOM runtime defaults to `document.cookie`, while non-DOM/SSR falls back to in-memory caching.
+     * @keywords cookie init setup listeners ssr
+     */
+    static init(getListener?: (key: string) => unknown, getListenerRaw?: () => string, setListener?: (key: string, value: string, cookie: string, options?: CookieOptions) => void): 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 */
+/** Resolution type for DataStorage.get return value with fallback handling. @keywords storage, return type */
+export type DataStorageGet<T, D = undefined> = [
+    D
+] extends [
+    undefined
+] ? (T | undefined) : unknown extends T ? (D extends () => infer R ? R : D) : T;
+/** Manages localStorage and sessionStorage with prefixing, expiration caching, and SSR request isolation. @keywords storage, localStorage, sessionStorage, cache, ssr */
+export declare class DataStorage<T = unknown> {
+    /** Initializes storage instance with key name, storage target, and error handler. @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 */
+    /** Retrieves item from storage with optional default fallback and cache TTL in seconds. @keywords storage, get, read, cache */
+    get<D extends T | (() => T) | undefined = undefined>(defaultValue?: D, cache?: number): DataStorageGet<T, D>;
+    /** Writes value or generator result to storage. @keywords storage, set, write */
     set(value?: T | (() => T)): T | undefined;
-    /** Removes item from storage. @keywords remove, delete, clear */
+    /** Returns fully-qualified storage key including prefix. @keywords storage, key, index, prefix */
+    getIndex(): string;
+    /** Sets process-wide key prefix for bootstrapping. @note Applies globally to entire runtime process in SSR. @keywords storage, prefix, config */
+    static setPrefix(newPrefix: string): void;
+    /** Deletes item from storage. @keywords storage, remove, delete, clear */
     remove(): this;
-    /** Synchronizes data from underlying storage. @keywords update, sync, refresh */
+    /** Synchronizes and refreshes data from storage. @keywords storage, sync, update, 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
+ * Class for working with dates, time, and internationalized calendar calculations.
+ * @remarks Creating a `Datetime` instance without a specific date (using the current time) for rendering in SSR may lead to hydration mismatches because the time or time zone on the server may differ from the time on the client.
+ * @keywords datetime, date, calendar, time, timezone, intl
  */
 export declare class Datetime {
-    /** Creates a Datetime instance. @keywords constructor datetime */
+    /** Initializes a Datetime instance with date, format type, and locale. @keywords init, constructor */
     constructor(date?: NumberOrStringOrDate, type?: GeoDate, code?: string);
-    /** Returns the GeoIntl formatting instance. @keywords intl format */
+    /** Returns the GeoIntl internationalization helper instance. @keywords intl, localization, format */
     getIntl(): GeoIntl;
-    /** Returns the underlying native Date object. @keywords date native */
+    /** Returns the underlying native Date instance. @keywords date, native */
     getDate(): Date;
-    /** Returns the configured date display format type. @keywords type format */
+    /** Returns the date output format type. @keywords type, format */
     getType(): GeoDate;
-    /** Returns the hour format type. @keywords hours format */
+    /** Returns the hour display format type. @keywords hours, format */
     getHoursType(): GeoHours;
-    /** Returns whether 24-hour time format is enabled. @keywords 24-hour format */
+    /** Checks whether the 24-hour time format is enabled. @keywords 24-hour, time format */
     getHour24(): boolean;
-    /** Returns the time zone offset in minutes relative to UTC. @keywords timezone offset utc */
+    /** Returns the country and language locale code. @keywords locale, language, country, code */
+    getCode(): string;
+    /** Returns the time zone offset in minutes relative to UTC. @keywords timezone, offset, utc */
     getTimeZoneOffset(): number;
-    /** Returns the time zone string. @keywords timezone */
+    /** Returns the formatted time zone string. @keywords timezone, tz */
     getTimeZone(style?: GeoTimeZoneStyle): string;
-    /** Returns the code of the first day of the week for the current locale. @keywords first day weekday */
+    /** Returns the first day of the week code for the current locale. @keywords first day, week, weekday */
     getFirstDayCode(): GeoFirstDay;
-    /** Returns the four-digit year according to local time. @keywords year local */
+    /** Returns the full year according to local time. @keywords year, local time */
     getYear(): number;
-    /** Returns the 1-based month index (1-12) according to local time. @keywords month local */
+    /** Returns the 1-based month (1-12) according to local time. @keywords month */
     getMonth(): number;
-    /** Returns the day of the month (1-31) according to local time. @keywords day month local */
+    /** Returns the day of the month (1-31) according to local time. @keywords day, day of month */
     getDay(): number;
-    /** Returns the hour (0-23) according to local time. @keywords hour local */
+    /** Returns the day of the week (0-6) according to local time. @keywords weekday, day of week */
+    getWeekday(): number;
+    /** Returns the hour (0-23) according to local time. @keywords hour, time */
     getHour(): number;
-    /** Returns the minute (0-59) according to local time. @keywords minute local */
+    /** Returns the minutes (0-59) according to local time. @keywords minute, time */
     getMinute(): number;
-    /** Returns the second (0-59) according to local time. @keywords second local */
+    /** Returns the seconds (0-59) according to local time. @keywords second, time */
     getSecond(): number;
-    /** Returns the total number of days (28-31) in the current month. @keywords days in month max day */
+    /** Returns the total number of days in the current month (28-31). @keywords max day, days in month */
     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 */
+    /** Sets the date value completely. @keywords set date */
+    setDate(value?: NumberOrStringOrDate): this;
+    /** Sets the date format output type. @keywords set type, format */
     setType(value: GeoDate): this;
-    /** Sets whether to use 24-hour time format. @keywords set 24-hour format */
+    /** Configures whether to use the 24-hour time format. @keywords 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 */
+    /** Updates the locale code and triggers watcher notification. @keywords set locale, code */
+    setCode(code?: string): this;
+    /** Registers a callback invoked whenever date values update. @keywords watch, listener, callback */
+    setWatch(watch?: (date: Date, type: GeoDate, hour24: boolean) => void): this;
+    /** Sets the full year in local time, clamping day to avoid month overflow. @keywords set year */
     setYear(value: number): this;
-    /** Sets the 1-based month (1-12) according to local time. @keywords set month */
+    /** Sets the 1-based month (1-12) in local time, clamping day to avoid overflow. @keywords set month */
     setMonth(value: number): this;
-    /** Sets the day of the month (1-31) according to local time. @keywords set day */
+    /** Sets the day of the month in local time. @keywords set day */
     setDay(value: number): this;
-    /** Sets the hour (0-23) according to local time. @keywords set hour */
+    /** Sets the hour in local time. @keywords set hour */
     setHour(value: number): this;
-    /** Sets the minute (0-59) according to local time. @keywords set minute */
+    /** Sets the minutes in local time. @keywords set minute */
     setMinute(value: number): this;
-    /** Sets the second (0-59) according to local time. @keywords set second */
+    /** Sets the seconds in local time. @keywords set second */
     setSecond(value: number): this;
-    /** Shifts the date by the specified number of years. @keywords move shift year */
+    /** Formats date and time according to locale and format options. @keywords locale, format, intl */
+    locale(type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions): string;
+    /** Formats the year according to locale options. @keywords format year, locale */
+    localeYear(style?: Intl.DateTimeFormatOptions['year']): string;
+    /** Formats the month according to locale options. @keywords format month, locale */
+    localeMonth(style?: Intl.DateTimeFormatOptions['month']): string;
+    /** Formats the day according to locale options. @keywords format day, locale */
+    localeDay(style?: Intl.DateTimeFormatOptions['day']): string;
+    /** Formats the hour according to locale options. @keywords format hour, locale */
+    localeHour(style?: Intl.DateTimeFormatOptions['hour']): string;
+    /** Formats the minute according to locale options. @keywords format minute, locale */
+    localeMinute(style?: Intl.DateTimeFormatOptions['minute']): string;
+    /** Formats the second according to locale options. @keywords format second, locale */
+    localeSecond(style?: Intl.DateTimeFormatOptions['second']): string;
+    /** Outputs date in standard format with optional timezone offset. @keywords standard, iso, format */
+    standard(timeZone?: boolean): string;
+    /** Shifts the date by a given number of years. @keywords move year, shift, offset */
     moveByYear(value: number): this;
-    /** Shifts the date by the specified number of months. @keywords move shift month */
+    /** Shifts the date by a given number of months. @keywords move month, shift, offset */
     moveByMonth(value: number): this;
-    /** Shifts the date by the specified number of days. @keywords move shift day */
+    /** Shifts the date by a given number of days. @keywords move day, shift, offset */
     moveByDay(value: number): this;
-    /** Shifts the date by the specified number of hours. @keywords move shift hour */
+    /** Shifts the date by a given number of hours. @keywords move hour, shift, offset */
     moveByHour(value: number): this;
-    /** Shifts the date by the specified number of minutes. @keywords move shift minute */
+    /** Shifts the date by a given number of minutes. @keywords move minute, shift, offset */
     moveByMinute(value: number): this;
-    /** Shifts the date by the specified number of seconds. @keywords move shift second */
+    /** Shifts the date by a given number of seconds. @keywords move second, shift, offset */
     moveBySecond(value: number): this;
-    /** Sets the month to January. @keywords january first month */
+    /** Sets the month to January. @keywords january, first month */
     moveMonthFirst(): this;
-    /** Sets the month to December. @keywords december last month */
+    /** 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 */
+    /** Moves 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 */
+    /** Moves 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 */
+    /** Moves date to the first day of the current week. @keywords first day, week */
     moveWeekdayFirst(): this;
-    /** Moves the date to the last day of the current week. @keywords last weekday week end */
+    /** Moves date to the last day of the current week. @keywords last day, week */
     moveWeekdayLast(): this;
-    /** Moves the date to the first day of the month's first week. @keywords month first weekday */
+    /** Moves date to the first day of the first week of the month. @keywords first week, calendar grid */
     moveWeekdayFirstByMonth(): this;
-    /** Moves the date to the first day of the next month's first full week. @keywords month last weekday */
+    /** Moves date to the last day of the last week of the month. @keywords last week, calendar grid */
     moveWeekdayLastByMonth(): this;
-    /** Advances the date by one week. @keywords next week */
+    /** Shifts date to the next week. @keywords next week */
     moveWeekdayNext(): this;
-    /** Moves the date back by one week. @keywords previous week */
+    /** Shifts date to the previous week. @keywords previous week */
     moveWeekdayPrevious(): this;
-    /** Moves the date to the first day of the current month. @keywords first day month start */
+    /** Moves date to the first day of the month. @keywords start of month, day first */
     moveDayFirst(): this;
-    /** Moves the date to the last day of the current month. @keywords last day month end */
+    /** Moves date to the last day of the month. @keywords end of month, day last */
     moveDayLast(): this;
-    /** Advances the date to the next day. @keywords next day tomorrow */
+    /** Shifts date forward by one day. @keywords next day, tomorrow */
     moveDayNext(): this;
-    /** Moves the date to the previous day. @keywords previous day yesterday */
+    /** Shifts date backward by one day. @keywords previous day, yesterday */
     moveDayPrevious(): this;
-    /** Creates a clone of the underlying native Date object. @keywords clone date */
+    /** Clones date as a native Date instance. @keywords clone date */
     clone(): Date;
-    /** Creates a clone of this Datetime instance. @keywords clone datetime */
+    /** Clones the Datetime instance. @keywords clone datetime */
     cloneClass(): Datetime;
-    /** Clones the Datetime instance with month set to January. @keywords clone january */
+    /** Clones Datetime instance and sets month to January. @keywords clone, january */
     cloneMonthFirst(): Datetime;
-    /** Clones the Datetime instance with month set to December. @keywords clone december */
+    /** Clones Datetime instance and sets month to December. @keywords clone, december */
     cloneMonthLast(): Datetime;
-    /** Clones the Datetime instance and advances it by one month. @keywords clone next month */
+    /** Clones Datetime instance and shifts one month ahead. @keywords clone, next month */
     cloneMonthNext(): Datetime;
-    /** Clones the Datetime instance and moves it back by one month. @keywords clone previous month */
+    /** Clones Datetime instance and shifts one month back. @keywords clone, previous month */
     cloneMonthPrevious(): Datetime;
-    /** Clones the Datetime instance set to the first day of the current week. @keywords clone week start */
+    /** Clones Datetime instance set to the first day of the week. @keywords clone, start of week */
     cloneWeekdayFirst(): Datetime;
-    /** Clones the Datetime instance set to the last day of the current week. @keywords clone week end */
+    /** Clones Datetime instance set to the last day of the week. @keywords clone, end of week */
     cloneWeekdayLast(): Datetime;
-    /** Clones the Datetime instance set to the first day of the month's first week. @keywords clone month week start */
+    /** Clones Datetime instance set to the first day of the first week of the month. @keywords clone, calendar start */
     cloneWeekdayFirstByMonth(): Datetime;
-    /** Clones the Datetime instance set to the last day of the month's last week. @keywords clone month week end */
+    /** Clones Datetime instance set to the last day of the last week of the month. @keywords clone, calendar end */
     cloneWeekdayLastByMonth(): Datetime;
-    /** Clones the Datetime instance advanced by one week. @keywords clone next week */
+    /** Clones Datetime instance shifted one week ahead. @keywords clone, next week */
     cloneWeekdayNext(): Datetime;
-    /** Clones the Datetime instance moved back by one week. @keywords clone previous week */
+    /** Clones Datetime instance shifted one week back. @keywords clone, previous week */
     cloneWeekdayPrevious(): Datetime;
-    /** Clones the Datetime instance set to the first day of the month. @keywords clone month start */
+    /** Clones Datetime instance set to the first day of the month. @keywords clone, start of month */
     cloneDayFirst(): Datetime;
-    /** Clones the Datetime instance set to the last day of the month. @keywords clone month end */
+    /** Clones Datetime instance set to the last day of the month. @keywords clone, end of month */
     cloneDayLast(): Datetime;
-    /** Clones the Datetime instance advanced by one day. @keywords clone next day */
+    /** Clones Datetime instance shifted one day ahead. @keywords clone, next day */
     cloneDayNext(): Datetime;
-    /** Clones the Datetime instance moved back by one day. @keywords clone previous day */
+    /** Clones Datetime instance shifted one day back. @keywords clone, previous day */
     cloneDayPrevious(): Datetime;
 }
 
-/** Manages error storage, registry, and handling. @keywords error center, error handling, error storage */
+/** Manages error storage and dispatching. @keywords error management, handler, error center */
 export declare class ErrorCenter {
-    /** Returns a request-isolated instance of ErrorCenterInstance. @keywords get item, instance, request isolated */
+    /** Retrieves a specific error cause by code and group. @keywords get error, find cause */
+    static get(code: string, group?: ErrorCenterGroup): ErrorCenterCauseItem | undefined;
+    /** Returns the error handler instance. @keywords error handler, get handler */
+    static getHandler(): ErrorCenterHandler;
+    /** Checks if an error cause exists for a code and group. @keywords check error, has cause */
+    static has(code: string, group?: ErrorCenterGroup): boolean;
+    /** Returns the global singleton instance of ErrorCenterInstance. @keywords singleton, instance */
     static getItem(): ErrorCenterInstance;
-    /** Checks if an error cause exists by code and group. @keywords has error, check cause, exists */
-    static has(code: string, group?: string): boolean;
-    /** Retrieves an error cause item by code and group. @keywords get error cause, find error */
-    static get(code: string, group?: string): ErrorCenterCauseItem | undefined;
-    /** Adds an error cause item to storage. @keywords add error cause, register error */
+    /** Configures console logging flag or filter for errors. @keywords console log, filter, debug */
+    static setIsConsole(isConsole: ErrorCenterHandlerIsConsole): void;
+    /** Adds an error cause item to storage. @keywords add error, register cause */
     static add(cause: ErrorCenterCauseItem): void;
-    /** Adds a list of error causes to storage. @keywords add error cause list, batch register */
-    static addList(causes: ErrorCenterCauseList): void;
-    /** Registers a handler callback for a specific error group. @keywords add error handler, register group handler */
+    /** Registers a global callback executed on any error. @keywords global error callback, listener */
+    static addCallback(callback: ErrorCenterHandlerCallback): void;
+    /** Registers an error handler for a specific group. @keywords register handler, group error */
     static addHandler(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): void;
-    /** Registers a list of error handlers. @keywords add handler list, register handlers */
+    /** Registers multiple error handlers simultaneously. @keywords batch handlers, handler list */
     static addHandlerList(handlers: ErrorCenterHandlerList): void;
-    /** Adds a global callback to execute on any error event. @keywords add callback, global error listener */
-    static addCallback(callback: ErrorCenterHandlerCallback): void;
-    /** Configures console output logging flag or filter predicate. @keywords set is console, console output, error logging */
-    static setIsConsole(isConsole: ErrorCenterHandlerIsConsole): void;
-    /** Triggers error handling and dispatches handlers for a cause. @keywords trigger error, dispatch error, on error */
+    /** Adds a list of error causes to storage. @keywords batch causes, error list */
+    static addList(causes: ErrorCenterCauseList): void;
+    /** Removes an error cause from storage by code and group. @keywords remove error, delete cause */
+    static remove(code: string, group?: ErrorCenterGroup): void;
+    /** Removes a specific handler or all handlers for a group. @keywords remove handler, unregister */
+    static removeHandler(group?: ErrorCenterGroup, handler?: ErrorCenterHandlerCallback): void;
+    /** Removes a registered global callback. @keywords remove callback, unbind */
+    static removeCallback(callback: ErrorCenterHandlerCallback): void;
+    /** Resets all registered handlers and callbacks. @keywords reset, clear handlers */
+    static reset(): void;
+    /** Dispatches error handling for a given cause. @keywords trigger error, dispatch, notify */
     static on(cause: ErrorCenterCauseItem): void;
 }
 
 /**
- * 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
+ * Advanced lifecycle-managed event listener wrapper with DOM-safety checks and optimizations for resize and scroll.
+ * @keywords event-listener dom-events resize-observer scroll-sync event-dispatch
+ * @example
+ * const clickEvent = new EventItem('.btn', 'click', (e) => console.log('Clicked!'));
+ * clickEvent.start();
  */
-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 */
+export declare class EventItem<E extends ElementOrWindow, O extends Event, D extends Record<string, unknown> = Record<string, unknown>> {
+    /** Creates an EventItem instance. @keywords constructor init */
     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 */
+    /** Checks whether event listening is currently active. @keywords active status listening */
     isActive(): boolean;
-    /** Returns the target DOM element or window. @keywords get element, target */
+    /** Returns the resolved target element. @keywords target element getter */
     getElement(): E | undefined;
-    /** Sets the target DOM element or selector for event listening. @keywords set element, target */
+    /** Updates the target element or selector. @keywords set-target element-bind */
     setElement(elementSelector?: ElementOrString<E>): this;
-    /** Sets the control element for DOM safety checks. @keywords element control, dom safety */
+    /** Sets the control element used for DOM attachment safety checks. @keywords dom-safety control-element */
     setElementControl<EC extends HTMLElement>(elementSelector?: ElementOrString<EC>): this;
-    /** Sets the handled event type or types. @keywords set type, event type */
+    /** Updates the event type or types to listen to. @keywords set-type event-type */
     setType(type: string | string[]): this;
-    /** Sets the event handler listener function. @keywords set listener, handler */
+    /** Updates the event listener callback. @keywords set-listener callback handler */
     setListener(listener: EventListenerDetail<O, D>): this;
-    /** Sets the event listener options. @keywords set options, event options */
+    /** Updates the event listener configuration options. @keywords options capture passive */
     setOptions(options?: EventOptions): this;
-    /** Sets custom detail data passed to the listener or dispatch. @keywords set detail, custom data */
+    /** Updates the custom detail payload passed to listeners. @keywords set-detail payload custom-event */
     setDetail(detail?: D): this;
-    /** Dispatches a CustomEvent on the target element with optional detail data. @keywords dispatch, trigger event, custom event */
+    /** Dispatches a CustomEvent with optional payload across configured event types. @keywords dispatch trigger fire */
     dispatch(detail?: D | undefined): this;
-    /** Starts listening to configured events. @keywords start, add event listener, attach */
+    /** Attaches and activates the event listeners. @keywords start listen attach */
     start(): this;
-    /** Stops listening to events. @keywords stop, remove event listener, detach */
+    /** Detaches and stops the event listeners. @keywords stop remove detach */
     stop(): this;
-    /** Toggles event listening state based on the provided active flag. @keywords toggle, enable, disable */
+    /** Toggles the active listening state based on the given boolean. @keywords toggle state active */
     toggle(activity: boolean): this;
-    /** Restarts active event listeners. @keywords reset, restart listener, reload */
+    /** Resets the event listener lifecycle by restarting if currently active. @keywords reset reload restart */
     reset(): this;
 }
 
-/** Formats a list or single data item based on provided column formatting options. @keywords format, list, data, options */
+/** Formats a dataset or single item using configured options. @keywords formatters, list format, data formatting */
 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 */
+    /** Initializes formatter options and dataset. @keywords constructor, initialize */
     constructor(options: Options, list?: List | undefined);
-    /** Checks if the list data is set. @keywords check, is set, exists */
+    /** Checks whether the dataset is defined. @keywords is, has data, exists */
     is(): boolean;
-    /** Type guard checking if the list data is an array. @keywords isArray, type guard */
+    /** Type guard checking whether the dataset is an array. @keywords isArray, type guard, array */
     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 */
+    /** Returns current dataset normalized as an array. @keywords getList, list, array */
     getList(): FormattersList<Item>;
-    /** Returns the current formatting options configuration. @keywords getOptions, configuration, settings */
+    /** Returns current formatting options configuration. @keywords getOptions, options, config */
     getOptions(): Options;
-    /** Sets the list of data to be formatted. @keywords setList, update, list */
+    /** Sets or updates the dataset to format. @keywords setList, update, dataset */
     setList(list?: List): this;
-    /** Formats the entire list or single item, appending formatted values with 'Format' suffixes. @keywords to, format, transform */
+    /** Returns the record count in the dataset. @keywords length, count, size */
+    length(): number;
+    /** Formats the dataset or single item and appends formatted values with 'Format' suffix. @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 */
+/** Static class providing centralized interface for managing locale, country, and time zone data. @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 */
+    /** Returns current country and language data. @keywords current, geo, country, language */
     static get(): GeoItemFull;
-    /** Returns the 2-letter code of the current country. @keywords country, code, iso */
+    /** Sets current geographical location and updates instance state. @keywords set, location, locale */
+    static set(code?: string, save?: boolean): void;
+    /** Resolves geo data by country or language code from global database. @keywords lookup, code, country, language */
+    static getByCode(code?: string): GeoItemFull;
+    /** Resolves exact geo data by matching full locale string (e.g., 'en-US'). @keywords lookup, exact, full, locale */
+    static getByCodeFull(code?: string): GeoItem | undefined;
+    /** Resolves geo data for specific country code. @keywords country, code, lookup */
+    static getByCountry(country?: string): GeoItem | undefined;
+    /** Resolves geo data for specific language code. @keywords language, code, lookup */
+    static getByLanguage(language?: string): GeoItem | undefined;
+    /** Returns 2-letter code of current country. @keywords country, code, current */
     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 */
+    /** Returns code for first day of the week for current locale. @keywords firstDay, week, locale */
     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 */
+    /** Returns fully processed geo data updated with current language. @note Deprecated: use get() @keywords item, current, language */
     static getItem(): GeoItemFull;
-    /** Returns the complete list of available countries and regions. @keywords list, countries, regions */
+    /** Returns 2-letter code of current language. @keywords language, code, current */
+    static getLanguage(): string;
+    /** Returns 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 */
+    /** Returns current location string. @keywords location, current */
+    static getLocation(): string;
+    /** Returns country code extracted from current location string. @keywords location, country, code */
+    static getLocationLanguage(): string;
+    /** Returns language code extracted from current location string. @keywords location, language, code */
+    static getLocationCountry(): string;
+    /** Returns request-isolated instance of GeoInstance. @keywords instance, isolated, request */
+    static getObject(): GeoInstance;
+    /** Returns combined locale string in standard format (e.g., 'en-US'). @keywords standard, locale, format */
+    static getStandard(): string;
+    /** Returns timezone offset in minutes for 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 */
+    /** Returns formatted timezone string (e.g., '+00:00') for 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 */
+    /** Sets custom timezone offset in minutes for current context. @keywords timezone, set, 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;
+    /** Sets default value or resolver for country code. @keywords default, country, code */
+    static setValueDefault(code?: string | (() => string | undefined)): void;
+    /** Adds or updates country geo data and merges with existing records. @keywords add, country, update */
+    static add(country: string, item?: Partial<GeoItem>): GeoInstance;
+    /** Adds or updates multiple countries in geo list. @keywords add, batch, countries, list */
+    static addList(list?: Record<string, Partial<GeoItem>>): GeoInstance;
+    /** Resolves geo data for given code. Alias for getByCode. @note Deprecated: use getByCode() @keywords find, lookup, code */
+    static find(code?: string): GeoItemFull;
+    /** Formats geo item into standard concatenated locale string (e.g., 'en-US'). @keywords standard, locale, format */
+    static toStandard(item?: GeoItem, language?: string, raw?: boolean): string;
 }
 
 export declare const GEO_FLAG_ICON_NAME = "f";
-/** Handles flags, country names, languages, and geographic metadata. @keywords geo, flag, country, language, locale */
+/** Country, language, and flag icon geographic utility. @keywords geo flag country language locale icon */
 export declare class GeoFlag {
-    /** Mapping of country codes to flag icon names. @keywords flags, country codes, icon map */
+    /** Country code to flag icon name mapping. @keywords flag icons mapping */
     static flags: Record<string, string>;
-    /** Initializes GeoFlag with an optional country/language code. @keywords geo flag, constructor, locale */
+    /** Creates a GeoFlag instance with an optional country/language code. @keywords constructor init */
     constructor(code?: string);
-    /** Retrieves country information and flag data by country code. @keywords country, flag, metadata */
+    /** Retrieves country and flag details. @keywords get country flag */
     get(code?: string): GeoFlagItem | undefined;
-    /** Retrieves language information and associated flag by code. @keywords language, flag, metadata */
+    /** Retrieves language and flag details. @keywords get language flag */
     getLanguage(code?: string): GeoFlagItem | undefined;
-    /** Returns the active country code. @keywords get code, country code, locale */
+    /** Returns the active country code. @keywords country code get */
     getCode(): string;
-    /** Returns the flag icon identifier for a given country code. @keywords flag icon, icon id */
+    /** Returns the flag icon identifier for a country code. @keywords flag icon code */
     getFlag(code?: string): string | undefined;
-    /** Retrieves a list of countries for specified codes or all available countries. @keywords country list, countries */
+    /** Returns country list, optionally filtered and sorted. @keywords list countries sort */
     getList(codes?: string[], sort?: boolean): GeoFlagItem[];
-    /** Retrieves a list of languages for specified codes or all available languages. @keywords language list, languages */
+    /** Returns language list, optionally filtered and sorted. @keywords list languages sort */
     getListLanguage(codes?: string[], sort?: boolean): GeoFlagItem[];
-    /** Retrieves a list of countries with names in their native languages. @keywords national countries, native names */
+    /** Returns country list with names in native languages. @keywords national countries native */
     getNational(codes?: string[], sort?: boolean): GeoFlagNational[];
-    /** Retrieves a list of languages with their native names. @keywords national languages, native names */
+    /** Returns language list with names in native languages. @keywords national languages native */
     getNationalLanguage(codes?: string[], sort?: boolean): GeoFlagNational[];
-    /** Updates the current country/language code. @keywords set code, update locale */
+    /** Updates the active locale or country code. @keywords set code locale */
     setCode(code: string): this;
 }
 
-/** Internationalization and localization utility providing language-sensitive formatting and comparison. @keywords intl localization i18n formatter */
+/** Internationalization and localization utility wrapper for ECMAScript Intl API. @keywords intl, i18n, l10n, localization, format */
 export declare class GeoIntl {
-    /** Checks if an instance exists for the specified country or locale code. @keywords localization check locale */
+    /** Creates a GeoIntl instance for a given country or locale code. @keywords constructor, locale, init */
+    constructor(code?: string, errorCenter?: ErrorCenterInstance);
+    /** Checks whether an instance exists for the specified country or locale code. @keywords exists, cache, check */
     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 */
+    /** Returns a cached or new GeoIntl instance for the specified 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 */
+    /** Returns the standard location code for a given country/locale. @keywords location, locale, code */
+    static getLocation(code?: string): string;
+    /** Returns the first day of the week for the locale. @keywords first day, week, start day */
     getFirstDay(): string;
-    /** Formats display names for languages, regions, scripts, or currencies. @keywords display names translation region */
+    /** Returns the current country and language locale code. @keywords location, locale, code */
+    getLocation(): string;
+    /** Translates language, region, or script display names. @keywords display, translate, intl */
     display(value?: string, typeOptions?: Intl.DisplayNamesOptions['type'] | Intl.DisplayNamesOptions): string;
-    /** Gets the localized display name of a language. @keywords language name locale */
+    /** Returns localized display name of a language code. @keywords language, display name */
     languageName(value?: string, style?: Intl.RelativeTimeFormatStyle): string;
-    /** Gets the localized display name of a country or region. @keywords country name region */
+    /** Returns localized display name of a region or country code. @keywords country, region, name */
     countryName(value?: string, style?: Intl.RelativeTimeFormatStyle): string;
-    /** Formats a full person name according to locale conventions. @keywords person full name formatting */
+    /** Returns a formatted full name according to locale rules. @keywords fullName, person, format */
     fullName(last: string, first: string, surname?: string, short?: boolean): string;
-    /** Formats numbers, strings, or bigints with localized numeric formatting. @keywords number format numeric */
+    /** Formats a number, bigint, or string value according to locale rules. @keywords number, format, digits */
     number(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Gets the localized decimal separator symbol. @keywords decimal separator point */
+    /** Returns the decimal point separator symbol for the locale. @keywords decimal, point, separator */
     decimal(): string;
-    /** Formats numbers as localized currency strings. @keywords currency money format */
+    /** Formats a numerical value as currency. @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 */
+    /** Returns the currency symbol or currency code. @keywords currencySymbol, currency, sign */
     currencySymbol(currency: string, currencyDisplay?: keyof Intl.NumberFormatOptionsCurrencyDisplayRegistry): string;
-    /** Formats a number with localized measurement units. @keywords unit measure format */
+    /** Formats a value with a specific measurement unit. @keywords unit, measurement, format */
     unit(value: NumberOrString, unitOptions?: string | Intl.NumberFormatOptions): string;
-    /** Formats digital file sizes into localized unit strings. @keywords file size byte format */
+    /** Returns a localized formatted file size string. @keywords sizeFile, bytes, file size */
     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 */
+    /** Formats a number as a percentage. @keywords percent, percentage, ratio */
     percent(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats a 0-100 numeric value as a localized percentage. @keywords percentage percent 100 */
+    /** Formats a fraction (0-1) as a percentage (0-100%). @keywords percentBy100, percentage, ratio */
     percentBy100(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats pluralized words matching locale rules (format: one|two|few|many|other|zero). @keywords plural pluralization words */
+    /** Applies plural-sensitive formatting and returns the appropriate word form. @keywords plural, rules, grammar */
     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 */
+    /** Formats date and time 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 */
+    /** Formats relative time from a given date. @keywords relative, time, 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 */
+    /** Formats relative time within a limit, otherwise falls back to standard date format. @keywords relativeLimit, relative, limit */
     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 */
+    /** Formats elapsed relative time for an explicit time unit. @keywords relativeByValue, relative, elapsed */
     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 */
+    /** Returns the localized month name for a given date. @keywords month, name */
     month(value?: NumberOrStringOrDate, style?: Intl.DateTimeFormatOptions['month']): string;
-    /** Returns an array of localized month names (1-12). @keywords months list options select */
+    /** Returns a localized list of all months. @keywords months, list, select */
     months(style?: Intl.DateTimeFormatOptions['month']): ItemValue<number | undefined>[];
-    /** Gets the localized weekday name for a given date. @keywords weekday name day */
+    /** Returns the localized day-of-week name for a given date. @keywords weekday, day, name */
     weekday(value?: NumberOrStringOrDate, style?: Intl.DateTimeFormatOptions['weekday']): string;
-    /** Returns an array of localized weekday names (0-6). @keywords weekdays list options select */
+    /** Returns a localized list of all days of the week. @keywords weekdays, list, select */
     weekdays(style?: Intl.DateTimeFormatOptions['weekday']): ItemValue<number | undefined>[];
-    /** Formats the time portion of a date according to locale conventions. @keywords time format clock */
+    /** Formats the time portion of a date. @keywords time, clock, format */
     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[];
+    /** Sorts an array of items using locale-sensitive string comparison. @keywords sort, collator, compare */
+    sort<T>(data: T[], compareFn?: (itemA: T, itemB: T) => [
+        string,
+        string
+    ]): T[];
 }
 
-/** Class for storing and processing phone number masks and country dialing codes. @keywords phone, mask, country code, dialing */
+/** Cookie key for storing the geo location code. @keywords cookie, geo, key */
+export declare const UI_GEO_COOKIE_KEY = "ui-geo-code";
+/** Manages and resolves the current location code, storage persistence, and DOM fallbacks. @keywords geo, location, locale, storage */
+export declare class GeoLocation {
+    /** Initializes location state from storage, cookies, DOM, or defaults. @keywords constructor, init, geo */
+    constructor(valueDefault?: string | (() => string | undefined) | undefined);
+    /** Gets the current location code string. @keywords get, location, code */
+    get(): string;
+    /** Updates the current location code with optional storage and cookie persistence. @keywords set, update, persist */
+    set(code?: string, save?: boolean): this;
+    /** Gets the country code extracted from the current location. @keywords country, code */
+    getCountry(): string;
+    /** Gets the language code extracted from the current location. @keywords language, locale */
+    getLanguage(): string;
+    /** Sets the default location code value or dynamic resolver. @keywords default, fallback */
+    setValueDefault(code?: string | (() => string | undefined)): this;
+}
+
+/** Manages phone number masks, country codes, and formatting. @keywords phone mask country code parser */
 export declare class GeoPhone {
-    /** Retrieves phone code and country information by country code. @keywords phone info, country code */
+    /** Retrieves phone code and country mask data by country or language code. @keywords phone mask country code lookup */
     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 */
+    /** Retrieves full phone mask map item by country code. @keywords phone mask map country */
     static getByCode(code: string): GeoPhoneMap | undefined;
-    /** Returns a list of all phone country codes and metadata. @keywords phone list, country codes */
+    /** Identifies country and mask metadata from a phone number string. @keywords phone metadata identify lookup */
+    static getByPhone(phone: string): GeoPhoneMapInfo;
+    /** Retrieves a list of all available phone mask items. @keywords phone masks list all */
     static getList(): GeoPhoneValue[];
-    /** Returns a map tree of phone data indexed by country code. @keywords phone map, dial tree */
+    /** Retrieves a tree map of phone mask configurations indexed by code. @keywords phone mask tree map */
     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 */
+    /** Strips leading zeros or country dialing prefix from a phone number. @keywords sanitize phone clean zero prefix */
     static removeZero(phone: string): string;
+    /** Formats a phone number according to matching or provided masks. @keywords format phone mask formatter */
+    static toMask(phone: string, masks?: string[]): string | undefined;
 }
 
-/** Localized unit formatting and automatic conversions based on locale. @keywords unit measurement locale conversion format */
+/** Localized unit formatting and automatic conversions for metric and regional units. @keywords unit, localization, conversion, measurement, geo */
 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 */
+    /** Creates a GeoUnit instance for a locale or country code. @keywords constructor, locale */
     constructor(code?: string);
-    /** Gets the standard location code. @keywords location locale country */
+    /** Gets a cached GeoUnit instance for the specified locale code. @keywords cache, instance, factory */
+    static getInstance(code?: string): GeoUnit;
+    /** Returns the resolved standard location code. @keywords location, country, locale */
     getLocation(): string;
-    /** Formats millimeter value, converting to inches for imperial locales. @keywords millimeter mm inch */
+    /** Formats millimeters, converting to inches if configured by locale. @keywords millimeter, length, distance, inch */
     millimeter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats centimeter value, converting to inches for imperial locales. @keywords centimeter cm inch */
+    /** Formats centimeters, converting to inches if configured by locale. @keywords centimeter, length, distance, inch */
     centimeter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats meter value, converting to feet for imperial locales. @keywords meter m foot feet */
+    /** Formats meters, converting to feet if configured by locale. @keywords meter, length, distance, foot */
     meter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats kilometer value, converting to miles for imperial locales. @keywords kilometer km mile */
+    /** Formats kilometers, converting to miles if configured by locale. @keywords kilometer, distance, mile */
     kilometer(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats square meter value, converting to square feet for imperial locales. @keywords square meter m2 sqft */
+    /** Formats square meters, converting to square feet if configured by locale. @keywords square meter, area, square foot */
     squareMeter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats hectare value, converting to acres for imperial locales. @keywords hectare ha acre */
+    /** Formats hectares, converting to acres if configured by locale. @keywords hectare, area, acre */
     hectare(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats gram value, converting to ounces for imperial locales. @keywords gram g ounce oz */
+    /** Formats grams, converting to ounces if configured by locale. @keywords gram, weight, mass, ounce */
     gram(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats kilogram value, converting to pounds for imperial locales. @keywords kilogram kg pound lb */
+    /** Formats kilograms, converting to pounds if configured by locale. @keywords kilogram, weight, mass, pound */
     kilogram(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats metric tonne value, converting to short tons for imperial locales. @keywords tonne ton */
+    /** Formats tonnes, converting to short tons if configured by locale. @keywords tonne, metric ton, mass, ton */
     tonne(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats milliliter value, converting to fluid ounces for imperial locales. @keywords milliliter ml floz */
+    /** Formats milliliters, converting to fluid ounces if configured by locale. @keywords milliliter, volume, fluid ounce */
     milliliter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats liter value, converting to gallons for imperial locales. @keywords liter l gallon gal */
+    /** Formats liters, converting to gallons if configured by locale. @keywords liter, volume, gallon */
     liter(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats Celsius value, converting to Fahrenheit for imperial locales. @keywords celsius fahrenheit temperature */
+    /** Formats celsius, converting to fahrenheit if configured by locale. @keywords celsius, temperature, fahrenheit */
     celsius(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats speed in km/h, converting to mph for imperial locales. @keywords kmh mph speed */
+    /** Formats kilometers per hour, converting to miles per hour if configured by locale. @keywords speed, kilometer per hour, mph */
     kilometerPerHour(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
-    /** Formats a numeric value for the specified unit according to locale settings. @keywords format unit locale convert */
+    /** Formats a numeric value for the specified unit according to locale rules. @keywords format, unit, conversion */
     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 */
+/** Static utility class for storing and retrieving application-wide global data. @keywords global state, storage, registry */
 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;
+    /** Retrieves a global value by property name. @keywords get, lookup, retrieve, state */
+    static get<R = unknown>(name: string): R;
+    /** Returns the entire global data storage record. @keywords storage, state, get all, dictionary */
+    static getItem(): Record<string, unknown>;
+    /** Initializes global data once. @keywords add, initialize, set global */
+    static add(data: Record<string, unknown>): void;
 }
 
-/** Static interface for managing URL hash state via HashInstance. @keywords url hash, router state, hash params */
+/** Static class managing data stored in the URL hash via HashInstance delegation. @keywords hash url state navigation routing */
 export declare class Hash {
-    /** Returns a request-isolated HashInstance. @keywords instance, singleton, context */
+    /** Returns a request-isolated HashInstance instance. @keywords hash instance isolate get */
     static getItem(): HashInstance;
-    /** Retrieves a value from the URL hash. @keywords hash get, read url param */
+    /** Retrieves a stored value by name from the URL hash with an optional default. @keywords get hash value read query */
     static get<T>(name: string, defaultValue?: T | (() => T)): T;
-    /** Sets or updates a value in the URL hash. @keywords hash set, update url param */
+    /** Sets or updates a value in the URL hash. @keywords set hash value update write */
     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 */
+    /** Subscribes a listener callback to changes for a specific hash variable. @keywords watch listener subscribe observe change */
     static addWatch<T>(name: string, callback: (value: T) => void): void;
-    /** Unsubscribes a listener callback from hash variable changes. @keywords unwatch, unsubscribe, remove listener */
+    /** Unsubscribes a listener callback from changes for a specific hash variable. @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 */
+    /** Synchronizes hash variables by reparsing the current URL string. @keywords reload sync refresh parse */
     static reload(): void;
+    /** Resets the instance, clears state, and removes all active listeners. @keywords reset destroy clear teardown */
+    static reset(): void;
 }
 
-export type IconsItem = string | Promise<string | any> | (() => Promise<string | any>);
+export type IconsItem = string | Promise<string | unknown> | (() => Promise<string | unknown>);
 export type IconsConfig = {
     url?: string;
     list?: Record<string, IconsItem>;
 };
-/** Icon manager utility for registering and loading icons. @keywords icons, icon-loader, assets */
+/** Icon manager for registering, caching, and retrieving icon assets. @keywords icon, icons, manager, registry */
 export declare class Icons {
-    /** Checks if an icon is registered. @keywords icons, has-icon, exists */
+    /** Checks whether an icon is registered by name. @keywords icon, check, exists, is */
     static is(index: string): boolean;
-    /** Retrieves icon content or path asynchronously. @keywords get-icon, async-icon, fetch-icon */
+    /** Asynchronously retrieves an icon by name or URL with optional timeout. @keywords icon, get, fetch, load, async */
     static get(index: string, url?: string, wait?: number): Promise<string>;
-    /** Synchronously returns an icon if loaded or string-based. @keywords get-sync, cached-icon */
+    /** Synchronously returns an icon if loaded or retrieves from string source. @keywords icon, getAsync, sync, cache */
     static getAsync(index: string, url?: string): string;
-    /** Retrieves a list of all registered icon names. @keywords icon-list, names */
+    /** Returns a list of all registered icon names. @keywords icon, list, names, keys */
     static getNameList(): string[];
-    /** Retrieves the global icon storage URL. @keywords global-url, base-url */
+    /** Returns the global base URL for icon storage. @keywords icon, url, global, base */
     static getUrlGlobal(): string;
-    /** Registers a custom icon definition. @keywords register-icon, add-icon */
+    /** Updates the icon configuration. @keywords icon, config, configure, settings */
+    static setConfig(config: IconsConfig): void;
+    /** Sets the global base URL for icon storage. @keywords icon, url, set, base */
+    static setUrl(url: string): void;
+    /** Registers a custom icon by name with a path, promise, or loader function. @keywords icon, register, add, custom */
     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 */
+    /** Registers multiple icons from a key-value map. @keywords icon, register, bulk, addByList, map */
     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;
+    /** Registers a global icon path by name. @keywords icon, global, register, addGlobal */
+    static addGlobal(index: string, file: string): void;
+    /** Marks an icon as being loaded. @keywords icon, load, loading, addLoad */
+    static addLoad(index: string): void;
+    /** Resets the icon registry to its default state. @keywords icon, reset, clear */
+    static reset(): void;
 }
 
-/** Class for managing global loading state. @keywords loading, loader, spinner, global */
+/** Manages global loading state and loader events. @keywords global loading, loader, spinner, state */
 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 */
+    /** Gets the current loading counter value. @keywords loading value, counter, progress */
     static get(): number;
-    /** Returns a request-isolated instance of LoadingInstance. @keywords loading instance, isolated */
+    /** Checks if the loader is currently active. @keywords is loading, active loader, status */
+    static is(): boolean;
+    /** Returns a request-isolated LoadingInstance object. @keywords loading instance, isolated loader, context */
     static getItem(): LoadingInstance;
-    /** Shows the loader. @keywords show loader, start loading */
+    /** Increments the loading counter and displays the loader. @keywords show loader, start loading, display spinner */
     static show(): void;
-    /** Hides the loader. @keywords hide loader, stop loading */
+    /** Decrements the loading counter and hides the loader when zero. @keywords hide loader, stop loading, dismiss spinner */
     static hide(): void;
-    /** Registers an event listener for loading state changes. @keywords loading event, add listener */
+    /** Registers an event listener for loading state changes. @keywords add event listener, loading event, watch */
     static registrationEvent(listener: EventListenerDetail<CustomEvent, LoadingDetail>, element?: ElementOrString<HTMLElement>): void;
-    /** Unregisters a loading state event listener. @keywords remove listener, unsubscribe */
+    /** Unregisters a previously added loading state event listener. @keywords remove event listener, unsubscribe, loading event */
     static 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 */
+/** Unified manager for standard HTML, Open Graph, and Twitter Card meta tags. @keywords meta, seo, open graph, twitter card, head */
 export declare class Meta extends MetaManager<MetaTag[]> {
-    /** Creates an instance of Meta with integrated Open Graph and Twitter Card support. @keywords constructor, init */
+    /** Initializes Meta manager with integrated Open Graph and Twitter Card support. @keywords constructor, init */
     constructor();
-    /** Gets the MetaOg instance for Open Graph operations. @keywords og, opengraph */
+    /** Gets the MetaOg instance for Open Graph operations. @keywords og, open graph */
     getOg(): MetaOg;
-    /** Gets the MetaTwitter instance for Twitter Card operations. @keywords twitter, card */
+    /** Gets the MetaTwitter instance for Twitter Card operations. @keywords twitter, twitter card */
     getTwitter(): MetaTwitter;
-    /** Gets the page title without suffix. @keywords title, get */
+    /** Gets the page title without suffix. @keywords title, get title */
     getTitle(): string;
-    /** Gets the keywords meta tag content. @keywords keywords, get */
+    /** Gets the keywords meta tag content. @keywords keywords, seo */
     getKeywords(): string;
-    /** Gets the description meta tag content. @keywords description, get */
+    /** Gets the description meta tag content. @keywords description, seo */
     getDescription(): string;
-    /** Gets the Open Graph image URL. @keywords image, og, get */
+    /** Gets the Open Graph image URL. @keywords image, og image */
     getImage(): string;
-    /** Gets the canonical URL. @keywords canonical, url, get */
+    /** Gets the canonical URL. @keywords canonical, url */
     getCanonical(): string;
-    /** Gets the robots meta tag directive. @keywords robots, crawler, get */
+    /** Gets the robots meta tag directive. @keywords robots, indexing, seo */
     getRobots(): MetaRobots;
-    /** Gets the author meta tag content. @keywords author, get */
+    /** Gets the author meta tag content. @keywords author */
     getAuthor(): string;
-    /** Gets the Open Graph site name. @keywords site_name, og, get */
+    /** Gets the Open Graph site name. @keywords site name, og */
     getSiteName(): string;
-    /** Gets the Open Graph locale. @keywords locale, og, get */
+    /** Gets the Open Graph locale. @keywords locale, og */
     getLocale(): string;
-    /** Sets the page title with suffix and updates Open Graph and Twitter Card titles. @keywords title, set */
+    /** Sets the page title with suffix and updates Open Graph and Twitter Card titles. @keywords set title, og title, twitter title */
     setTitle(title: string): this;
-    /** Sets the keywords meta tag. @keywords keywords, set */
+    /** Sets the keywords meta tag from a string or string array. @keywords keywords, set keywords */
     setKeywords(keywords: string | string[]): this;
-    /** Sets the description meta tag. @keywords description, set */
+    /** Sets the description meta tag. @keywords description, set description */
     setDescription(description: string): this;
-    /** Sets the image for Open Graph and Twitter Card. @keywords image, og, twitter, set */
+    /** Sets the image URL for Open Graph and Twitter Card. @keywords image, og image, twitter image */
     setImage(image: string): this;
-    /** Sets the canonical URL and updates Open Graph and Twitter Card URLs. @keywords canonical, url, set */
+    /** Sets the canonical URL and updates Open Graph and Twitter Card URLs. @keywords canonical, url */
     setCanonical(canonical: string): this;
-    /** Sets the robots meta tag directive. @keywords robots, indexing, set */
+    /** Sets the robots meta directive tag. @keywords robots, indexing, crawler */
     setRobots(robots: MetaRobots): this;
-    /** Sets the author meta tag. @keywords author, set */
+    /** Sets the author meta tag. @keywords author */
     setAuthor(author: string): this;
-    /** Sets the site name for Open Graph and Twitter Card. @keywords site_name, og, set */
+    /** Sets the site name for Open Graph and Twitter Card. @keywords site name, og */
     setSiteName(siteName: string): this;
-    /** Sets the Open Graph locale. @keywords locale, og, set */
+    /** Sets the locale for Open Graph. @keywords locale, og locale */
     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 */
+    /** Sets the suffix to append to the page title. @keywords suffix, title suffix */
+    setSuffix(suffix?: string): this;
+    /** Generates the complete HTML string for all meta tags. @keywords html, render, tags */
     html(): string;
-    /** Generates the title as an HTML-safe string. @keywords title, html, render */
+    /** Generates the HTML-safe page title string. @keywords html title, render title */
     htmlTitle(): string;
 }
 
-/** Static facade for managing URL query parameters. @keywords url, query params, search params, routing */
+/** Static utility providing centralized access to URL query parameters delegating to QueryInstance. @keywords query, search-params, url */
 export declare class Query {
-    /** Returns a request-isolated QueryInstance. @keywords instance, query instance, singleton */
+    /** Returns a request-isolated instance of QueryInstance. @keywords query-instance, get-item, context */
     static getItem(): QueryInstance;
-    /** Retrieves a parameter value from the query string with an optional default. @keywords get query, query parameter, read url */
+    /** Retrieves a parameter value from the URL query with an optional default value or getter. @keywords get, query-param, read */
     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 */
+    /** Sets or updates a parameter value in the URL query. @keywords set, query-param, update, write */
     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 */
+    /** Registers a listener callback for changes to a specific query parameter. @keywords add-watch, listener, observe, query-change */
     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 */
+    /** Unregisters an existing change listener callback for a query parameter. @keywords remove-watch, unwatch, 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 */
+    /** Re-parses and updates query variables from the current URL string. @keywords reload, refresh, sync-url */
     static reload(): void;
+    /** Resets the instance and removes all attached listeners. @keywords reset, destroy, cleanup, clear */
 }
 
-/** Timer that can be paused, resumed, reset, and cleared. @keywords timer, pause, resume, timeout, delay */
+/** Timer that can be paused, resumed, reset, and cleared. @keywords timer, pause, resume, delay, timeout, schedule */
 export declare class ResumableTimer {
-    /** Creates a resumable timer instance. @param blockStart If true, timer will not start immediately. @keywords timer, init */
+    /** Creates a new resumable timer instance. @keywords constructor, create, timer */
     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 */
+    /** Resets and restarts the timer with the original delay. @keywords reset, restart, timer */
     reset(): this;
-    /** Completely clears and cancels the timer. @keywords clear, cancel, destroy */
+    /** Clears the timer and resets its state. @keywords clear, stop, cancel, timer */
     clear(): this;
+    /** Pauses the timer and preserves remaining time. @keywords pause, freeze, timer */
+    pause(): this;
+    /** Resumes a paused timer or starts it if not running. @keywords resume, start, unpause, timer */
+    resume(): this;
 }
 
-/** Utility class for calculating and managing scrollbar width. @keywords scrollbar, scroll width, layout, measurement */
+/** Utility for measuring and caching browser scrollbar width. @keywords scrollbar width measurement scroll */
 export declare class ScrollbarWidth {
-    /** Checks whether scrollbar hiding should be enabled. @keywords scrollbar, visibility, check, hide */
+    /** Checks whether scrollbar hiding should be enabled. @keywords scrollbar check hide enabled */
     static is(): Promise<boolean>;
-    /** Computes and returns the scrollbar width in pixels. @keywords scrollbar, width, measure, pixels */
+    /** Gets the scrollbar width in pixels. @keywords scrollbar width size pixels measure */
     static get(): Promise<number>;
-    /** Returns the storage instance holding the cached scrollbar width. @keywords scrollbar, storage, cache */
+    /** Returns the storage instance caching the scrollbar width. @keywords scrollbar storage cache */
     static getStorage(): DataStorage<number>;
-    /** Checks if scrollbar width calculation is currently in progress. @keywords scrollbar, calculate, state, status */
+    /** Checks if scrollbar width calculation is currently in progress. @keywords scrollbar calculate status flag */
     static getCalculate(): boolean;
 }
 
-/** Manages searchable lists, coordinating options, item state, matching logic, and storage. @keywords search, list, filter, data */
+/** Manages searchable lists, coordinating options, item state, matching, and data storage. @keywords search list, filter, match coordinator */
 export declare class SearchList<T extends SearchItem, K extends SearchColumns<T>> {
-    /** Initializes a new SearchList instance. @keywords search list, constructor */
+    /** Creates a new SearchList instance. @keywords initialize, 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 */
+    /** Retrieves the configured search columns. @keywords get columns, search fields */
     getColumns(): K | undefined;
-    /** Gets the search item instance. @keywords item, search item */
+    /** Retrieves the search data manager instance. @keywords get data, data manager */
+    getData(): SearchListData<T, K>;
+    /** Retrieves the search item manager instance. @keywords get item, item state */
     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 */
+    /** Retrieves the current list of items. @keywords get list, source items */
+    getList(): SearchListValue<T>;
+    /** Retrieves the search options instance. @keywords get options, search configuration */
     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 */
+    /** Retrieves the active search query string. @keywords get value, search query */
+    getValue(): string | undefined;
+    /** Sets search columns and invalidates 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 */
+    /** Sets a new list of items and invalidates the cache. @keywords set list, update items */
+    setList(list: SearchListValue<T>): this;
+    /** Sets search options and updates the matcher. @keywords set options, configure */
     setOptions(options: SearchOptions): this;
-    /** Processes and returns the formatted list based on the current search state. @keywords format, process, filter results */
+    /** Sets a new search query and updates the matcher. @keywords set value, query filter */
+    setValue(value?: string): this;
+    /** Processes and returns the formatted list based on current search criteria. @keywords format, search results, execute */
     to(): SearchFormatList<T, K>;
 }
 
-type ServerStorageItem = {
-    value: any;
+export type ServerStorageItem = {
+    value: unknown;
     hydration: boolean;
 };
-type ServerStorageList = Record<string, ServerStorageItem>;
-/** Manages isolated data storage during SSR across parallel requests. @keywords ssr, storage, isolation, context */
+export type ServerStorageList = Record<string, ServerStorageItem>;
+/** Manages request-isolated data storage and client hydration during SSR. @keywords ssr, storage, hydration, 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 */
+    /** Checks whether a key exists in storage. @keywords has, exists, check */
     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 */
+    /** Retrieves a value from storage or initializes it with a fallback. @keywords get, read, default, hydration */
+    static get<T = unknown>(key: string, defaultValue?: (() => T) | T, hydration?: boolean): T;
+    /** Saves a value to storage with optional client hydration flag. @keywords set, store, write, hydration */
+    static set<T = unknown>(key: string, value: (() => T) | T, hydration?: boolean, storageList?: ServerStorageList): T;
+    /** Sets the visibility of error messages. @keywords error, status, logging */
     static setErrorStatus(hide: boolean): void;
-    /** Removes a value from storage by key. @keywords remove, delete */
+    /** Removes a key and its value from storage. @keywords remove, delete, purge */
     static remove(key: string): void;
-    /** Serializes the hydration storage into an executable script tag string. @keywords hydration, serialize, toString */
+    /** Resets the storage state. @keywords reset, clear, flush */
+    static reset(): void;
+    /** Initializes storage with a per-request context provider. @keywords init, setup, context, listener */
+    static init(listener: () => Record<string, unknown> | undefined): typeof ServerStorage;
+    /** Serializes hydratable storage state into a script string. @keywords toString, serialize, hydration, script */
     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 */
+/** Manages storage callback lists and execution state. @keywords storage, callbacks, listeners */
+export declare class StorageCallback<T = unknown, Callback = (value: T) => void | Promise<void>> {
+    /** Initializes a storage callback manager. @keywords constructor, init */
     constructor(name: string, group?: string);
-    /** Checks whether storage is currently in a loading state. @keywords loading state check */
+    /** Checks whether callbacks or storage are currently loading. @keywords loading, state, status */
     isLoading(): boolean;
-    /** Gets the storage identifier name. @keywords name identifier */
-    getName(): string;
-    /** Gets the current loading state value. @keywords loading status */
+    /** Returns or creates an instance by storage name and group. @keywords singleton, instance, lookup */
+    static getInstance<T>(name: string, group?: string): StorageCallback<T>;
+    /** Returns the current loading state. @keywords loading, state */
     getLoading(): boolean;
-    /** Subscribes a callback function to storage events. @keywords subscribe listener add once */
+    /** Returns the storage name identifier. @keywords name, identifier */
+    getName(): string;
+    /** Registers a callback listener to the list. @keywords add, listener, callback, subscribe */
     addCallback(callback: Callback, isOnce?: boolean): this;
-    /** Unsubscribes a callback function from storage events. @keywords unsubscribe listener remove */
+    /** Removes a callback listener from the list. @keywords remove, unsubscribe, callback */
     removeCallback(callback: Callback): this;
-    /** Prepares storage callback state prior to execution. @keywords prepare init state */
+    /** Prepares state and data before execution. @keywords prepare, setup, init */
     preparation(): this;
-    /** Executes all registered callbacks asynchronously with the provided value. @keywords trigger emit execute dispatch */
+    /** Executes all registered callbacks with the provided storage value. @keywords run, execute, notify, trigger */
     run(value: T): Promise<this>;
 }
 
-/** Translation service for loading and resolving localized texts. @keywords translate, i18n, localization, dictionary */
+/** Global translation manager for retrieving and configuring localized text. @keywords translate, i18n, localization, l10n */
 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;
+  /** Retrieves translated text asynchronously by code with optional replacements. @keywords get, translate, async, i18n */
+  static get(name: string, replacement?: string[] | Record<string, string | number>): Promise<string>;
+  /** Returns the global singleton instance of TranslateInstance. @keywords getItem, instance, singleton */
+  static getItem(): TranslateInstance;
+  /** Retrieves multiple translations asynchronously by an array of text codes. @keywords getList, batch, translate, async */
+  static getList<T extends TranslateCode[]>(names: T): Promise<TranslateList<T>>;
+  /** Retrieves multiple translations synchronously by an array of text codes. @keywords getListSync, batch, translate, sync */
+  static getListSync<T extends TranslateCode[]>(names: T, first?: boolean): TranslateList<T>;
+  /** Retrieves translated text synchronously by code with optional replacements. @keywords getSync, translate, sync */
+  static getSync(name: string, first?: boolean, replacement?: string[] | Record<string, string | number>): string;
+  /** Sets global configuration for the translation service. @keywords setConfig, config, setup */
+  static setConfig(config: TranslateConfig): void;
+  /** Changes the property name used to retrieve translations. @keywords setPropsName, property, configuration */
+  static setPropsName(name: string): void;
+  /** Changes the API read mode for translations. @keywords setReadApi, api, mode */
+  static setReadApi(value: boolean): void;
+  /** Changes the URL path to the script for fetching translations. @keywords setUrl, endpoint, api */
+  static setUrl(url: string): void;
+  /** Registers a list of translation codes to be loaded. @keywords add, load, translations */
+  static add(names: string | string[]): Promise<void>;
+  /** Adds translation key-value pairs via request or directly depending on environment. @keywords addNormalOrSync, register, translations */
+  static addNormalOrSync(data: Record<string, string>): Promise<void>;
+  /** Adds translation key-value pairs synchronously into memory. @keywords addSync, register, sync */
+  static addSync(data: Record<string, string>): void;
+  /** Adds translations synchronously from a file data object. @keywords addSyncByFile, file, import */
+  static addSyncByFile(data: TranslateDataFile): void;
+  /** Adds translations grouped by location synchronously. @keywords addSyncByLocation, location, locale */
+  static addSyncByLocation(data: Record<string, Record<string, string>>): void;
 }
 
-/** Isomorphic utility class for URL parsing, manipulation, and query parameter management. @keywords url, parser, query, uri */
+/** Isomorphic utility class for URL parsing, manipulation, and serialization @keywords url, parser, route, query */
 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 */
+    /** Creates a new UrlItem instance @keywords constructor, url, create */
     constructor(url?: string | URL);
-    /** Full URL string representation. @keywords href, url, link */
+    /** Gets the serialized full URL string @keywords href, url, address */
     get href(): string;
-    /** Protocol scheme including trailing colon. @keywords protocol, scheme, http, https */
+    /** Gets the protocol scheme including the trailing colon @keywords protocol, scheme, http, https */
     get protocol(): string;
-    /** Username component of URL credentials. @keywords username, auth, credentials */
+    /** Gets the username specified before the domain name @keywords username, auth, credentials */
     get username(): string;
-    /** Password component of URL credentials. @keywords password, auth, credentials */
+    /** Gets the password specified before the domain name @keywords password, auth, credentials */
     get password(): string;
-    /** Host containing hostname and port. @keywords host, domain, port */
+    /** Gets the host including hostname and port @keywords host, domain, port */
     get host(): string;
-    /** Hostname excluding port number. @keywords hostname, domain */
+    /** Gets the domain name or IP without the port @keywords hostname, domain */
     get hostname(): string;
-    /** Port number string. @keywords port, network */
+    /** Gets the port number portion of the URL @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 */
+    /** Gets the resource pathname @keywords pathname, path, route */
     get search(): string;
-    /** Read-only URLSearchParams query parameters object. @keywords searchParams, query, params */
+    /** Gets the search query string including the leading question mark @keywords search, query, params */
+    get pathname(): string;
+    /** Gets the URLSearchParams object representing search parameters @keywords searchParams, query, urlsearchparams */
     get searchParams(): URLSearchParams;
-    /** Fragment identifier including leading hash sign. @keywords hash, fragment, anchor */
+    /** Gets the fragment identifier hash string including the leading hash symbol @keywords hash, fragment, anchor */
     get hash(): string;
-    /** Read-only origin of the URL (scheme + host). @keywords origin, domain, base */
+    /** Gets the serialized origin of the URL @keywords origin, domain, protocol */
     get origin(): string;
-    /** Checks if the specified query parameter exists. @param name Parameter name @keywords hasParam, query, exists, search */
+    /** Updates the internal URL value @keywords set, update, parse */
+    set(url?: string | URL): this;
+    /** Checks whether the specified query parameter exists @keywords hasParam, query, contains, exists */
     hasParam(name: string): boolean;
-    /** Gets the value of a specific query parameter. @param name Parameter name @keywords getParam, query, parameter */
+    /** Gets a request-isolated instance of UrlItem @keywords getInstance, singleton, request */
+    static getInstance(): UrlItem;
+    /** Gets the value of a specific query parameter @keywords getParam, query, search */
     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 */
+    /** Gets all query parameters as an object with converted types @keywords getParams, query, dictionary */
+    getParams(): Record<string, unknown>;
+    /** Sets the value of a query parameter @keywords setParam, query, search */
     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 */
+    /** Replaces all query parameters with values from the specified object @keywords setParams, query, batch */
+    setParams(params: Record<string, unknown>): this;
+    /** Removes a query parameter by name @keywords deleteParam, query, remove */
     deleteParam(name: string): this;
-    /** Serializes the URL instance to its full string representation. @keywords toString, serialize, string */
+    /** Converts the URL instance to its full string representation @keywords toString, stringify, serialize */
     toString(): string;
-    /** Serializes the URL instance to a JSON string representation. @keywords toJSON, serialize, json */
+    /** Converts the URL instance to its JSON string representation @keywords toJSON, json, serialize */
     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;
+export interface AddTagHighlightMatchOptions {
+    className?: string;
+    shouldEscape?: boolean;
+    shouldRemoveTag?: boolean;
+}
+/** Wraps matched substrings in an HTML tag for visual search highlighting. @keywords highlight, search, match, tag, mark, html */
+export declare function addTagHighlightMatch(value?: string | number | null, search?: string | RegExp, options?: AddTagHighlightMatchOptions): 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;
+export interface AnyToStringOptions {
+  isArrayString?: boolean;
+  isBooleanString?: boolean;
+  trim?: boolean;
+}
 
-/** 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;
+/**
+ * Safely converts any value to a string with configurable array, boolean, and trimming rules.
+ * @keywords any to string, convert, cast, serialize, stringify
+ * @example
+ * anyToString('  Hello  ') // => 'Hello'
+ * anyToString('  Hello  ', { trim: false }) // => '  Hello  '
+ * anyToString([1, 2, 3]) // => '1,2,3'
+ * anyToString([1, 2, 3], { isArrayString: false }) // => '[1,2,3]'
+ * anyToString({ a: 1 }) // => '{"a":1}'
+ * anyToString(true) // => '1'
+ * anyToString(false) // => '0'
+ * anyToString(true, { isBooleanString: true }) // => 'true'
+ * anyToString(false, { isBooleanString: true }) // => 'false'
+ * anyToString(null) // => ''
+ */
+export declare function anyToString<V = unknown>(value?: V, options?: AnyToStringOptions): string;
+
+/** Replaces template placeholders in text with values from an object or array. @keywords template, replace, interpolate, string format, placeholders */
+export declare function applyTemplate(text: unknown, replacement?: Record<string, unknown> | readonly unknown[]): 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>;
+/** Converts a Blob to a Base64 string, optionally removing the data URL prefix. @keywords blob, base64, convert, data url, file, encode */
+export declare function blobToBase64(blob?: Blob | null, 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;
+export declare function capitalize<T = string>(value?: T, locale?: boolean | string): T extends string ? Capitalize<T> : string;
 
-/** Creates a deep copy of an object to prevent unwanted mutations. @keywords deep copy, clone, duplicate */
+/** Creates a deep copy of an object to prevent unintended mutations. @keywords deep copy clone duplicate object */
 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 a shallow copy of an object with optional additional properties. @keywords copy, clone, shallow copy, object lite, merge */
+export declare function copyObjectLite<T = Record<PropertyKey, unknown>, R = T>(value?: T | null, source?: Record<PropertyKey, unknown> | null): R;
+
+/**
+ * Creates an HTML element, configures attributes or runs a modifier callback, and optionally appends it to a parent node.
+ * @remarks Returns `undefined` during SSR. Uses `document.createElement`; use `document.createElementNS` for SVG/MathML. Sanitize input when providing `innerHTML` through options.
+ * @keywords createElement, dom, html, create element, insert node
+ */
+export declare function createElement<T extends HTMLElement = HTMLDivElement>(parentElement?: Element | DocumentFragment | null, tagName?: string, options?: Partial<T> | Record<string, unknown> | ((element: T) => void) | null, referenceElement?: Node | null): T | undefined;
 
 /**
- * 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
+ * Executes a callback when DOMContentLoaded fires, or immediately if the DOM is already loaded.
+ * @remarks In non-DOM environments (SSR), execution can be disabled by passing `isServer: false`.
+ * @keywords dom, ready, domContentLoaded, ssr, readyState, event
  */
-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;
+export declare function domContentLoaded<T = void>(callback?: (() => T | Promise<T>) | null, isServer?: boolean): Promise<T>;
 
-/** 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>;
+/**
+ * Returns an array of all elements at the specified coordinates.
+ * @remarks In non-DOM (SSR) environments or when `document.elementsFromPoint` is unsupported, the function returns an empty array `[]`. Coordinates are evaluated relative to the viewport.
+ * @keywords dom, elementsFromPoint, hit test, coordinates, viewport elements
+ */
+export declare function domElementsFromPoint(coordinator?: ImageCoordinator | null): Element[];
 
-/** Selects the first element matching specified CSS selectors. @keywords dom, querySelector, element, find, select */
+/** Selects the first element matching the specified selectors. @keywords dom, querySelector, find element */
 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 */
+/** Selects all DOM elements matching the specified selectors. @keywords dom, querySelectorAll, selector, query, 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 for safe use in HTML attributes.
+ * @keywords html, attribute, encode, escape, sanitize
+ * @example
+ * 
+ * encodeAttribute('<div class="box">') // => '&lt;div class=&quot;box&quot;&gt;'
+ * encodeAttribute(undefined) // => ''
+ * 
+ */
+export declare function encodeAttribute(text?: string | number | null): 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;
+/**
+ * Encodes basic HTML special characters (<, >, &) while preserving quotes.
+ * @keywords html encode, escape html, lite attribute, html entities, title encode
+ * @example
+ * encodeLiteAttribute('Tom & Jerry') // => 'Tom &amp; Jerry'
+ * encodeLiteAttribute('<title> "Hello" </title>') // => '&lt;title&gt; "Hello" &lt;/title&gt;'
+ * encodeLiteAttribute(undefined) // => ''
+ * @remarks Does NOT encode quotes (" and '). For untrusted input inside HTML attributes, use `encodeAttribute`.
+ */
+export declare function encodeLiteAttribute(text?: string | number | null): string;
 
-/** Resizes an image if it exceeds the maximum size, returning base64 data. @keywords image resize compress max-size base64 */
+/** Resizes an image if it exceeds the maximum size, returning base64 encoded data. @keywords resize, compress, image, 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;
+/** Escapes special regex characters in a string or number for safe RegExp usage. @keywords escape, regex, regexp, sanitize, pattern */
+export declare function escapeExp(value?: string | number | null): string;
 
-/** Prevents further propagation of the given event in the DOM. @keywords event, stopPropagation, prevent bubbling */
+/** Stops event propagation in the DOM tree. @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;
+/** Executes a callback with arguments if callable, or returns the value as is. @keywords execute, invoke, call, callback, function or value */
+export declare function executeFunction<T, Args extends unknown[] = unknown[]>(callback: T | FunctionArgs<never, T> | ((...args: Args) => T), ...args: Args): T;
+
+/** Safely executes a function, promise, or static value and awaits its resolution. @keywords execute promise, async executor, run promise, safe call */
+export declare function executePromise<T, Args extends unknown[] = unknown[]>(callback: ((...args: Args) => PromiseLike<T> | T) | PromiseLike<T> | T, ...args: Args): Promise<Awaited<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>;
+export type ForEachData<T = any> = readonly T[] | Record<PropertyKey, T> | Map<unknown, T> | Set<T> | object;
+export type ForEachItem<D> = D extends readonly (infer T)[] ? T : D extends Set<infer S> ? S : D extends Map<unknown, infer V> ? V : D extends object ? D[keyof D] : unknown;
+export type ForEachKey<D> = D extends readonly unknown[] ? number : D extends Set<infer S> ? S : D extends Map<infer K, unknown> ? K : string;
+export type ForEachReturn<R, S extends boolean = false> = (S extends true ? R : Exclude<R, undefined>)[];
+/** Iterates over collection items (Array, Object, Map, Set) executing a callback and returning mapped results, omitting undefined unless specified. @keywords foreach, iterate, map, collection, array, object, set */
+export declare function forEach<T = any, R = any, D extends ForEachData<T> = ForEachData<T>, K = ForEachKey<D>, S extends boolean = false>(data: D, callback: (item: D extends object ? ForEachItem<D> : T, key: K, collection: D) => R, saveUndefined?: S): ForEachReturn<R, S>;
 
-/** 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[];
+/** Iterates over own enumerable object properties safely skipping prototype pollution keys, supporting early exit when false is returned. @keywords forOwn, iterate, loop, object, enumerable, prototype pollution */
+export declare function forOwn<T extends object = Record<string, unknown>, K extends Extract<keyof T, string> = Extract<keyof T, string>>(data?: T, callback?: (value: T[K], key: K, collection: T) => void | boolean): void;
 
-/** 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;
+/** Cyclically calls requestAnimationFrame while the next predicate returns true. @keywords requestAnimationFrame animation loop frame ticker */
+export declare function frame(callback: (timestamp: DOMHighResTimeStamp) => void, next?: (timestamp: DOMHighResTimeStamp) => boolean, end?: () => void): void;
 
-/** Splits a string into segments to highlight search matches. @keywords highlight, match, search, split, text */
+/** Splits a string into an array of text segments highlighting search matches. @keywords highlight match, string split, text search, regex */
 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 */
+/** Gets a key-value record of attributes for an element. @keywords attributes, dom, element, element 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 */
+/** Retrieves string data from the clipboard event or returns an empty string. @keywords clipboard, paste, copy, read, getClipboardData */
 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 */
@@ -997,71 +1115,81 @@ export declare function getCurrentDate(format?: GeoDate): string;
  */
 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;
+/** Resolves a selector string, Element, or Window to a DOM element (or document.body for Window). @keywords element, querySelector, getElement, resolve, dom, window, ssr */
+export declare function getElement<E extends ElementOrWindow = HTMLElement, R extends ElementResolved<E> = ElementResolved<E>>(element?: ElementOrString<E> | null): R | undefined;
 
-/** Returns the element ID or generates a new unique ID if missing. @keywords element id, generate id, get id, dom id */
+/** Returns or generates a unique element ID, targeting document.body if Window is provided. @keywords element id, get id, generate 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.
+ * Initializes the getElementId function with a context ID provider.
  * @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
+ * 
+ * @keywords init element id, ssr id provider, listener setup
  */
 export declare function initGetElementId(newListener: () => string | number): void;
+/** Resets the getElementId listener. @keywords reset element id, clear id listener */
+export declare function resetGetElementId(): 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;
+export type GetElementImageCallback = (image: HTMLImageElement, event?: Event | string) => void;
+/**
+ * Resolves or creates an HTMLImageElement from an existing element or URL string.
+ * @remarks
+ * If `image` is a string, a new `HTMLImageElement` is created with load and error callbacks attached before assigning `src`.
+ * If already an `HTMLImageElement`, it is returned directly. Returns `undefined` for null, undefined, or in SSR environments.
+ * Created elements are not attached to the DOM tree.
+ * @keywords image, HTMLImageElement, load image, image loader, create element, DOM
+ */
+export declare function getElementImage(image?: HTMLImageElement | string | null, onload?: GetElementImageCallback, onerror?: GetElementImageCallback): 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;
+/** Retrieves an element property by key, resolving to document.body for Window instances, or returning a default value. @keywords element property get value dom window document */
+export declare function getElementItem<E extends ElementOrWindow = HTMLElement, K extends keyof ElementResolved<E> = keyof ElementResolved<E>, D = undefined>(element?: ElementOrString<E> | null, property?: K | string | number, defaultValue?: D): ElementResolved<E>[K] | D;
 
-/** 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;
+/** Resolves the specified selector or element, returning the Element or preserving the Window object directly. @keywords dom, window, element, selector, querySelector, getElementOrWindow */
+export declare function getElementOrWindow<E extends ElementOrWindow = HTMLElement>(element?: ElementOrString<E> | null): 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;
+/** Generates a safe HTML script tag containing serialized data for client hydration. @keywords safe script, hydration, state transfer, serialization, html */
+export declare function getElementSafeScript<T = unknown>(id: string | number, data?: T): 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 */
+/** Creates a RegExp object with the escaped value substituted into the pattern. @keywords regex, regexp, pattern, match, escape */
 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;
+/** Returns the first element of an array or object. @keywords first, head, element, array, object */
+export declare function getFirst<T = undefined>(value?: T | readonly T[] | Record<PropertyKey, T>): T;
 
-/** 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;
+/** Retrieves and parses JSON hydration data from a script element in the DOM. @keywords hydration, script tag, json parse, dom state */
+export declare function getHydrationData<T>(id: string | number, 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;
+/** Extracts the image source string from an HTMLImageElement, object with a src property, or string URL. @keywords image, src, url, source, extract */
+export declare function getImageSrc(image?: HTMLImageElement | Record<string, unknown> | string | null): 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;
+/** Retrieves a nested value from an object by its path. @keywords get by path, object path, nested property, deep get */
+export declare function getItemByPath<T extends Record<string, unknown>, 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 last element of an array or object. @keywords last, element, tail, array, object */
+export declare function getLast<T = undefined>(value?: T | readonly T[] | Record<PropertyKey, T>): T;
 
-/** 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 length or size of arrays, objects, maps, sets, or strings, or 0 if unsupported or empty. @keywords length, size, count, collection, array, object, map, set, string */
+export declare function getLength(value: unknown): number;
 
-/** Returns the lengths of all string elements in an array or object. @keywords length, count, elements, array, string length */
+/** Returns the lengths of all string elements in an array or object. @keywords length, elements, string length, count */
 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 */
+/** Finds the shortest string in an array or object and returns its length. @keywords min length, shortest string, 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 */
@@ -1073,32 +1201,37 @@ 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>;
+/** Creates a new object composed of the picked keys from the source object. @keywords pick, subset, filter keys, extract */
+export declare function getObjectByKeys<T extends Record<string, unknown>, K extends keyof T>(data: T, keys: K[]): Pick<T, K>;
+
+/** Removes elements matching the exception value from an array and returns an indexed object. @keywords filter, omit, clean, undefined, array to object */
+export declare function getObjectNoUndefined<V>(data: readonly V[], exception?: unknown): Record<number, V>;
+/** Removes properties matching the exception value from an object. @keywords filter, omit, clean, undefined, compact */
+export declare function getObjectNoUndefined<T extends Record<PropertyKey, unknown>>(data: T, exception?: unknown): T;
 
-/** 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;
+/** Creates a prototype-less object (`Object.create(null)`), optionally copying properties from the provided data. @keywords object create null prototype dictionary clean */
+export declare function getObjectNull<T = unknown>(data?: Record<string, T>): Record<string, 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>;
+/** Returns the object if its values are set, or an empty object. @keywords object fallback empty validate */
+export declare function getObjectOrNone<T>(value: T): T & Record<string, unknown>;
 
-/** Strips special characters, returning only alphanumeric characters and spaces. @keywords sanitize, clean, alphanumeric, strip, text */
-export declare function getOnlyText(text: any): string;
+/** Extracts only letters, numbers, and spaces from a value. @keywords sanitize, clean, alphanumeric, text, filter */
+export declare function getOnlyText(text: unknown): 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 */
+/** Generates random text with specified word count and length constraints. @keywords random, text, generator, words, string */
 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;
+/** Serializes an object or array into a key-value request string. @keywords request string, query string, serialize, key value, params */
+export declare function getRequestString(request: Record<string, unknown> | readonly unknown[], 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;
+/** Builds a case-insensitive RegExp matching strings containing all specified words in any order. @keywords regex search query multi-word lookahead */
+export declare function getSearchExp(search?: unknown, 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;
+/** Creates a case-insensitive, global word-separating search RegExp or clones an existing RegExp. @keywords search regexp regex query filter words */
+export declare function getSeparatingSearchExp(search?: unknown, 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;
@@ -1106,183 +1239,280 @@ export declare function getStepPercent(min: number | undefined, max: number): nu
 /** 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;
+/** Quickly scrolls a container element or selector to the specified target element with optional centering and indent offset. @keywords scroll, scrollTo, goScroll, container scroll, scroll into view */
+export declare function goScroll(target: string | HTMLElement, elementTo?: HTMLElement | null, elementCenter?: HTMLElement | null, indent?: number): 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;
+/** Smoothly scrolls the viewport to a specified element with an optional top offset. @keywords smooth scroll, scroll to element, scrollIntoView, scroll offset */
+export declare function goScrollSmooth(element?: HTMLElement | Element | null, 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;
+/** Scrolls a container to make the target element visible. @keywords scroll, scrollTo, container, element, view */
+export declare function goScrollTo(container?: HTMLElement | Element | null, elementTo?: HTMLElement | Element | null, 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 an object has the specified own property. @keywords hasKey, hasOwnProperty, object, key, property check */
+export declare function hasKey<K extends PropertyKey = PropertyKey, T extends object = Record<K, unknown>>(object: unknown, key: K): object is T & Record<K, unknown>;
+
+/** Checks whether an object has at least one own property. @keywords hasKeys, object, keys, own properties, not empty */
+export declare function hasKeys<T extends object = Record<PropertyKey, unknown>>(object: unknown): object is T;
+
 /** 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]>;
+/** Computes the intersection of two objects based on their keys. @keywords intersect, intersection, keys, pick, compare */
+export declare function intersectKey<T extends Record<PropertyKey, unknown>, C extends Record<PropertyKey, unknown>>(data?: T | null, comparison?: C | null): Pick<T, Extract<keyof T, keyof C>>;
 
-/** Checks if an API response is successful. @keywords api, response, success, check, validate */
-export declare const isApiSuccess: <T>(data: ApiData<T>) => boolean;
+/** Checks if the API response indicates success. @keywords api, response, success, status, check */
+export declare function 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 a value is an array. @keywords isArray, array, type guard */
+export declare function isArray<T = unknown>(value: unknown): value is T[];
 
-/** 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 values of two objects are different. @keywords compare, diff, equality, object difference */
+export declare function isDifferent<T = unknown>(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 */
+/** Checks whether code is running in a browser environment with `window` available. @keywords dom, browser, runtime, window, client */
 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 an element is visible in the DOM and not hidden by CSS. @keywords visibility, dom, is visible, element, hidden */
+export declare function isElementVisible<E extends ElementOrWindow = HTMLElement>(elementSelectors?: ElementOrString<E> | null): 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 the pressed key is Enter or Space (WAI-ARIA action key) outside of text inputs. @keywords enter space wai-aria keyboard event */
+export declare function 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 a value is filled (not empty), optionally considering '0' as filled. @keywords isFilled, empty check, filled, validation */
+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;
+export declare function isFloat(value: unknown): 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 whether a value is a function. @keywords isFunction, function check, type guard, predicate */
+export declare function isFunction<T>(callback: T): callback is Extract<T, FunctionAnyType>;
 
 /** 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 an element is an input field or editable. @keywords input, editable, form element, check, dom */
+export declare function isInput(element?: HTMLElement | EventTarget | null, includeDisabled?: boolean): element is HTMLElement;
 
 /** 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 keyboard event contains active modifier or meta keys. @keywords meta key, modifier, keyboard event, ctrl, alt, shift, cmd */
+export declare function isMetaKey(event: KeyboardEvent): boolean;
 
-/** Checks if a value is null or undefined. @keywords isNull, isNil, null, undefined, check */
+/** Checks if a value is null or undefined. @keywords isNull, isNil, null, undefined, check, guard */
 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 the value is a number, numeric string, or bigint. @keywords isNumber, is numeric, check number, bigint, numeric string */
+export declare function isNumber(value?: unknown): value is number | string | bigint;
 
-/** 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 a value is an object. @keywords isObject, object, type guard */
+export declare function isObject<T = unknown>(value: unknown): value is ObjectItem<T>;
 
-/** 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>;
+/** Checks if the value is an object and not an array. @keywords isObjectNotArray, object, not array, record, type guard */
+export declare function isObjectNotArray<T>(value: T): value is Exclude<Extract<T, ObjectItem>, unknown[] | 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 a property key is a prototype pollution key (__proto__, constructor, prototype). @keywords prototype pollution, security, safe key, sanitize, proto, constructor */
+export declare function isPrototypeKey(key: unknown): boolean;
+
+/** Checks if a value is a regular expression (including cross-realm instances). @keywords regex, regexp, regular expression, type guard */
+export declare function isRegExp(value: unknown): value is RegExp;
 
-/** Checks if all items in a list are present in the selected values. @keywords isSelectedByList, selection, contains all, match list */
+/** Checks if a value matches a target or array of selected values with numeric equivalence support. @keywords isSelected, selection, match, compare */
+export declare function isSelected<T = unknown>(value?: T, selected?: unknown): boolean;
+
+/** Checks if all specified values are selected. @keywords select, isSelected, selection, list, comparison */
 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 value is of type string. @keywords is string, type guard, validation */
+export declare function isString(value?: unknown): value is 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 pressed key is Tab. @keywords tab key keyboard event check */
+export declare function isTab(event: KeyboardEvent): boolean;
 
-/** Checks if the given object is a Window instance. @keywords window, isWindow, dom, type guard */
+/** Checks if an object is a Window instance. @keywords window, isWindow, type guard, DOM */
 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 */
+/** Generates a random integer within the specified range (inclusive). @keywords random, integer, range, math, number */
 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;
+/** Removes the common prefix from a string, optionally trimming the result. @keywords string prefix remove strip trim */
+export declare function removeCommonPrefix(mainString: string, prefix: string, trim?: boolean): 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;
+export interface RemoveTagOptions {
+    tag?: string | string[];
+    replacement?: string;
+    removeContent?: boolean | string | string[];
+}
+/**
+ * Removes all HTML/XML tags or specified tags from a string.
+ * @keywords html, xml, strip tags, sanitize, remove tag, strip html
+ * @remarks
+ * When `removeContent` is true (or a list of tags is provided),
+ * executable and styling tags (`<script>`, `<style>`, `<noscript>`) or specified content tags
+ * are silently removed along with their inner content without applying `replacement`.
+ * Other formatting and layout tags preserve their text content, and their tag syntax
+ * is replaced with `replacement`.
+ * @example
+ * 
+ * removeTag('<p>Hello <b>world</b>!</p>') // => 'Hello world!'
+ * removeTag('<b>Hello</b> <p>world</p>', { tag: 'b' }) // => 'Hello <p>world</p>'
+ * removeTag('<b>Hello</b> <p>world</p>', { tag: ['b', 'p'] }) // => 'Hello world'
+ * removeTag('<p>Hello</p><p>world</p>', { replacement: ' ' }) // => ' Hello  world '
+ * removeTag('<p>Hello</p><script>alert(1)</script>') // => 'Hello'
+ * removeTag('<p>Hello</p><script>alert(1)</script>', { removeContent: false }) // => 'Helloalert(1)'
+ * removeTag('<div>Text</div><script>alert(1)</script>', { tag: 'script', removeContent: false }) // => '<div>Text</div>alert(1)'
+ * 
+ */
+export declare function removeTag(value?: string | number | null, options?: RemoveTagOptions): string;
 
-/** 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 occurrences of a component name within the provided text. @keywords replace component name, text replacement, rename component */
+export declare function replaceComponentName(text: string | undefined, name: string, componentName: string): string | undefined;
 
-/** 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;
+/**
+ * Recursively merges a target object with elements from a replacement object or array without mutating source data.
+ * @warning Intended exclusively for plain JSON-like objects and arrays; built-in class instances (`Date`, `RegExp`, `Map`, `Set`) and functions are not supported.
+ * @keywords deep merge, recursive replace, object merge, immutable merge
+ */
+export declare function replaceRecursive<I = unknown>(target?: ObjectItem<I> | null, replacement?: ObjectOrArray<I> | readonly I[] | null, isMerge?: boolean, disableCopy?: boolean): ObjectItem<I>;
+
+/** Replaces `[key]` placeholders in a template string with matching values or function results. @keywords template, replace, placeholder, substitute, string interpolation */
+export declare function replaceTemplate(value: string, replaces: Record<string, FunctionOr<string | number | boolean>>): 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;
+export type ResizeImageByMaxType = 'auto' | 'width' | 'height';
+
+/**
+ * Resizes an image to fit within a maximum size constraint using HTML Canvas.
+ * @remarks Synchronous; requires a fully loaded image with valid natural dimensions. Returns a Base64 Data URL only when scaled; returns `undefined` if already within `maxSize` or unprocessable to prevent redundant Canvas re-encoding. For a fallback to the original source, use `resizeImage`.
+ * @keywords image resize, scale image, max dimension, canvas resize, thumbnail, base64 data url
+ */
+export declare function resizeImageByMax(image: HTMLImageElement | string, maxSize: number, type?: ResizeImageByMaxType, typeData?: string, quality?: number): string | undefined;
 
-/** Converts seconds into a formatted time string (e.g. HH:MM:SS or MM:SS). @keywords time, format, seconds, duration, timestamp, clock */
+/** Validates and normalizes an external locale code string for URL safety and ECMA-402 BCP-47 compatibility. @keywords locale, sanitize, normalize, bcp47, ecma402 */
+export declare function sanitizeLocation(code?: unknown): string | undefined;
+
+/** Converts seconds into a formatted time string (MM:SS or HH:MM:SS). @keywords time format, seconds to time, duration, timestamp */
 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 the value of an element property, attribute, or style by key. @keywords element attribute property style set modify */
+export declare function setElementItem<E extends ElementOrWindow = HTMLElement, K extends keyof E = keyof E, V extends E[K] = E[K]>(element?: ElementOrString<E> | null, index?: K | string, value?: V | Record<string, V> | unknown): boolean;
+
+/** Sets or removes an HTML or ARIA attribute on a DOM element. @keywords set attribute, remove attribute, html attribute, aria attribute, dom */
+export declare function setElementItemAttribute<E extends ElementOrWindow = HTMLElement>(element?: ElementOrString<E> | null, attribute?: string, value?: unknown): boolean;
+
+/** Sets or merges nested properties on an element with prototype pollution protection. @keywords set element property, merge properties, prototype pollution */
+export declare function setElementItemProperty<E extends ElementOrWindow = HTMLElement>(element?: ElementOrString<E> | null, index?: PropertyKey, value?: unknown): boolean;
+
+/** Sets style properties, CSS custom properties, or cssText on a DOM element or window. @keywords style, css properties, custom properties, cssText, set element style */
+export declare function setElementItemStyle<E extends ElementOrWindow = HTMLElement>(element?: ElementOrString<E> | null, styles?: unknown): boolean;
+
+export interface SetValuesOptions {
+    multiple?: boolean;
+    maxlength?: number;
+    alwaysChange?: boolean;
+    notEmpty?: boolean;
+}
+/** Modifies or toggles single or multiple selected values according to configuration options. @keywords set values, toggle selection, collection, update */
+export declare function setValues<T>(selected: T | T[] | undefined, value: T, options?: SetValuesOptions): T | T[] | 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;
+/** Asynchronously skips specified animation frames or executes a callback within them, resolving immediately in non-DOM/SSR. @keywords skip frame, animation frame, raf, requestAnimationFrame, ssr */
+export declare function skipFrame<T = void>(callback?: () => T | Promise<T>, count?: number): Promise<T | void>;
 
 /** 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[];
+/** Sorts an array of items by column paths, directions, or a custom comparison function. @keywords sort, order, multi-column, comparator, array */
+export declare function sortList<T = Record<string, unknown>>(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>;
+/**
+ * Recursively merges properties from a replacement object into a target object, optionally replacing a matched entry in place.
+ * @warning Supports plain JSON-like objects only; built-in instances (`Date`, `RegExp`, `Map`, `Set`) and functions are not supported.
+ * @keywords splice, merge, object, replace, recursive
+ */
+export declare function splice<I = unknown>(array?: ObjectItem<I> | null, replacement?: ObjectItem<I> | I | null, indexStart?: string | null): 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[];
+/** Splits a string by a separator with a limit where the last element retains the remainder. @keywords string split, separator, limit, remainder, tokenize */
+export declare function strSplit(value?: unknown, 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 value to an array or returns it as-is if already an array. @keywords toArray, array wrap, ensure array, cast array */
+export declare function toArray<T>(value: T): T extends unknown[] ? 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 camelCase. @keywords camelCase, string, case conversion */
+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 string to PascalCase (CamelCase with first letter capitalized). @keywords pascalCase, camelCase, capitalize, case conversion */
+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 */
+/** Extracts and validates a 2-letter country code from a location or locale string. @keywords country, locale, bcp47, geolist, parse country */
+export declare function toCountry(code?: unknown, raw?: boolean): string;
+
+/** Converts a value to a Date object. @keywords date, parse, convert, timestamp */
 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;
+/** Finds geographical country and locale data by language-country, country, or language code. @keywords geo, country, locale, language code, geo item */
+export declare function toGeoItem(code?: unknown): GeoItem | undefined;
+
+/** Transforms a basic geo item into a full geo item with resolved location data and defaults. @keywords geo item, location resolution, defaults, country code */
+export declare function toGeoItemFull(item: GeoItem, code?: string): GeoItemFull;
+
+/** Converts a geo item to its standard string representation (language-country). @keywords geo standard country language code format */
+export declare function toGeoStandard(item?: GeoItem, language?: string, raw?: boolean): string;
+
+/** Converts a string to kebab-case format by replacing spaces and separators with hyphens. @keywords kebab-case, dash-case, slugify, string */
+export declare function toKebabCase(value?: string): string;
+
+/** Extracts and validates a canonical language code from a location or language string (BCP-47, ISO 639). @keywords language, locale, bcp47, iso639, geolist, parse, normalize */
+export declare function toLanguage(code?: unknown, raw?: boolean): string;
+
+/** Converts a full locale string into canonical standard 'aa-AA' format, or returns an empty string if incomplete. @keywords locale, canonicalize, format, language, country */
+export declare function toLocale(code?: unknown): 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
+ * Converts a value to a finite floating-point number, normalizing separators and stripping non-numeric characters.
+ * @keywords parse, float, number, cast, numeric conversion, separator
  * @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;
+export declare function toNumber(value?: unknown): 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 number clamped by a maximum permissible value, with optional formatting. @keywords toNumberByMax, clamp, max, number, format */
+export declare function toNumberByMax(value?: NumberOrString, max?: NumberOrString, 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 positive finite number (> 0), or returns a fallback value.
+ * @keywords toNumberPositive, positive number, parse positive, sanitize number
+ * @example
+ * toNumberPositive(15) // 15
+ * toNumberPositive('10') // 10
+ * toNumberPositive(-5) // 0
+ * toNumberPositive('invalid', 1) // 1
+ */
+export declare function toNumberPositive(value?: NumberOrString | null, defaultValue?: number): number;
+
+/** Converts a string to PascalCase. @keywords pascal case, string transform, formatting, casing */
+export declare function toPascalCase(value?: string): string;
 
 /** 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;
@@ -1293,22 +1523,35 @@ 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;
+/**
+ * Transforms a string into its corresponding data type (boolean, number, object, null, undefined, or function).
+ * @keywords transform, parse, cast, deserialize, type conversion
+ * @example
+ * transformation('true') // true
+ * transformation('12.5') // 12.5
+ * transformation('{"a":1}') // { a: 1 }
+ * transformation('null') // null
+ */
+export declare function transformation<T = unknown>(value?: unknown, isFunctionCheck?: boolean): T;
 
-/** Converts a Uint8Array to a base64-encoded string. @keywords base64, uint8array, encode, binary, string */
-export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
+/**
+ * Converts a Uint8Array to a base64 encoded string across Node.js, modern ECMAScript, and browsers.
+ * @keywords uint8array, base64, encode, binary, buffer, btoa
+ * @example
+ * uint8ArrayToBase64(new Uint8Array([72, 101, 108, 108, 111])) // "SGVsbG8="
+ */
+export declare function uint8ArrayToBase64(bytes?: Uint8Array | null): string;
 
-/** Removes duplicate elements from an array. @keywords unique, deduplicate, distinct, array, filter */
-export declare function uniqueArray<T>(value: T[]): T[];
+/** Removes duplicate elements from an array. @keywords unique, deduplicate, distinct, array */
+export declare function uniqueArray<T = unknown>(value?: readonly T[] | null): T[];
 
-/** Writes text data to the system clipboard. @keywords clipboard, copy, write, buffer */
+/** Writes text data to the system clipboard. @keywords clipboard, copy, write, text */
 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 */
+/** HTTP request methods. @keywords http, method, rest, verb */
 export declare enum ApiMethodItem {
     delete = "DELETE",
     get = "GET",
@@ -1316,14 +1559,14 @@ export declare enum ApiMethodItem {
     put = "PUT",
     patch = "PATCH"
 }
-/** Cached API response entry @keywords cache store item */
+/** Cached API response structure. @keywords cache, response, ttl, storage */
 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 */
+/** Configuration options for the API client. @keywords api, config, options, client */
 export type ApiConfig = {
     urlRoot?: string;
     origin?: string;
@@ -1336,7 +1579,7 @@ export type ApiConfig = {
     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 */
+/** API response validation metadata. @keywords validation, response, status, error */
 export type ApiDataValidation = {
     status?: ApiStatusType;
     code?: string | number;
@@ -1346,7 +1589,7 @@ export type ApiDataValidation = {
         message?: string;
     };
 };
-/** API response payload and metadata wrapper @keywords response payload data */
+/** Unified API response payload wrapped with status and error metadata. @keywords response, wrapper, payload, data */
 export type ApiDataItem<T = any> = T & ApiDataValidation & {
     data?: T;
     success?: boolean;
@@ -1355,7 +1598,7 @@ export type ApiDataItem<T = any> = T & ApiDataValidation & {
 };
 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 */
+/** Parameters and execution options for API fetch requests. @keywords fetch, request, options, http */
 export type ApiFetch = {
     api?: boolean;
     path?: string;
@@ -1385,7 +1628,7 @@ export type ApiFetch = {
     endResetLimit?: number;
     wrapper?: <R>(callback: () => Promise<R>, apiFetch: ApiFetch) => Promise<R>;
 };
-/** Preloaded hydration data for API response matching @keywords hydration preload ssr */
+/** SSR hydration record for matching and preloading API responses. @keywords hydration, ssr, match */
 export type ApiHydrationItem = {
     path: string;
     method: ApiMethod;
@@ -1393,23 +1636,23 @@ export type ApiHydrationItem = {
     response: any;
 };
 export type ApiHydrationList = ApiHydrationItem[];
-/** API error mapping and interception configuration @keywords error storage interceptor */
+/** Error matching rule descriptor for API error management. @keywords error, handler, matcher, storage */
 export type ApiErrorStorageItem = Record<string, any> & {
     url: string | RegExp;
     method: ApiMethodItem;
-    code?: string;
+    code?: string | number;
     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 */
+/** Hook return value containing state reset flag and payload data. @keywords hook, lifecycle, reset */
 export type ApiPreparationEnd = {
     reset?: boolean;
     data?: any;
 };
-/** Mock API response descriptor and matching rules @keywords mock response stub */
+/** Mock API response rule descriptor. @keywords mock, response, test, stub */
 export type ApiResponseItem = {
     path: string | RegExp;
     method: ApiMethod;
@@ -1419,7 +1662,7 @@ export type ApiResponseItem = {
     isForGlobal?: boolean;
     lag?: any;
 };
-/** API request status and error tracking descriptor @keywords status tracker state */
+/** Execution status state and metadata for the last API request. @keywords status, error, response, state */
 export type ApiStatusItem = {
     status?: number;
     statusText?: string;
@@ -1432,7 +1675,7 @@ export type ApiStatusItem = {
 export type ApiStatusType = 'success' | 'error' | 'warning' | 'info';
 
 export type Undefined = undefined | null;
-/** Union of empty or falsy values and their string equivalents @keywords empty, falsy, nullish, blank */
+/** Union representing falsy, nullish, or string-serialized empty values @keywords empty, nullish, falsy */
 export type EmptyValue = Undefined | 0 | false | '' | 'undefined' | 'null' | '0' | 'false' | '[]';
 export type NumberOrString = number | string;
 export type NumberOrStringOrBoolean = number | string | boolean;
@@ -1441,7 +1684,7 @@ 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 the element type from an array type @keywords array, unwrap, element, infer */
+/** Unwraps an array type to its element type @keywords array, unwrap, extract */
 export type ArrayToItem<T> = T extends any[] ? T[number] : T;
 export type FunctionOr<T = any> = T | FunctionReturn<T>;
 export type FunctionReturn<R = any> = () => R;
@@ -1450,32 +1693,34 @@ 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;
+    index: string;
+    value: V;
 };
 export type ItemValue<V> = {
-  label: string;
-  value: V;
+    label: string;
+    value: V;
 };
 export type ItemName<V> = {
-  name: string | number;
-  value: V;
+    name: string | number;
+    value: V;
 };
-export type ElementOrWindow = HTMLElement | Window;
+export type ElementOrWindow = HTMLElement | SVGElement | Element | Window;
+/** Resolves ElementOrWindow types, substituting Window with HTMLElement @keywords element, dom, window */
+export type ElementResolved<E extends ElementOrWindow = HTMLElement> = E extends Window ? HTMLElement : Exclude<E, Window>;
 export type ElementOrString<E extends ElementOrWindow> = E | string;
 export type EventOptions = AddEventListenerOptions | boolean | undefined;
-/** Event listener callback with optional custom detail payload @keywords event, listener, detail, callback */
+/** Event listener accepting an event and an optional custom detail payload @keywords event, listener, detail */
 export type EventListenerDetail<O extends Event, D extends Record<string, any>> = (event: O, detail?: D) => void;
-/** Active event listener or observer tracking entry @keywords event, listener, observer, activity */
+/** Tracks an active event listener or observer registration @keywords event, listener, observer, activity */
 export type EventActivityItem<E extends ElementOrWindow> = {
-  element: E | undefined;
-  type: string;
-  listener?: (event: any | Event) => void;
-  observer?: ResizeObserver;
+    element: E | undefined;
+    type: string;
+    listener?: (event: any | Event) => void;
+    observer?: ResizeObserver;
 };
 export type ImageCoordinator = {
-  x: number;
-  y: number;
+    x: number;
+    y: number;
 };
 
 export type ErrorCenterGroup = string | undefined;
@@ -1574,89 +1819,84 @@ export type FormattersReturn<List extends FormattersListProp, Options extends Fo
 
 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;
+/** Default first day of the week ('Mo' = Monday). @keywords calendar, first_day, locale */
+export declare const GEO_DEFAULT_FIRST_DAY = "Mo";
 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 */
+/** Geographic item configuration for country, language, and regional formats. @keywords geo, country, language, locale, unit */
 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;
-  };
+    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 */
+/** Complete geographic item with resolved locale and location identifiers. @keywords geo, location, locale, country */
 export interface GeoItemFull extends Omit<GeoItem, 'firstDay'> {
-  standard: string;
-  firstDay: string;
-  location: string;
-  locationCountry: string;
-  locationLanguage: string;
+    standard: string;
+    firstDay: string;
+    location: string;
+    locationCountry: string;
+    locationLanguage: string;
 }
-
-/** Geographic flag and country display metadata @keywords flag, country, language */
+/** Country flag selection and display item. @keywords flag, country, language, option */
 export interface GeoFlagItem {
-  language: string;
-  languageCode: string;
-  country: string;
-  countryCode: string;
-  standard: string;
-  icon?: string;
-  label: string;
-  value: string;
-  phoneCode?: string;
+    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 */
+/** Extended geographic flag item containing localized national language and country names. @keywords flag, national, localization */
 export interface GeoFlagNational extends GeoFlagItem {
-  description: string;
-  nationalLanguage: string;
-  nationalCountry: string;
+    description: string;
+    nationalLanguage: string;
+    nationalCountry: string;
 }
-
-/** Country phone prefix and mask pattern metadata @keywords phone, mask, countryCode */
+/** Phone dialing configuration and mask metadata for a country. @keywords phone, country_code, mask, dialing */
 export interface GeoPhoneValue {
-  phone: number;
-  within: number;
-  mask: string[];
-  value: string;
+    phone: number;
+    within: number;
+    mask: string[];
+    value: string;
 }
-
-/** Prefix tree node for phone code lookup and mask formatting @keywords phone, trie, prefix, mask */
+/** Node in the internal phone prefix tree (Trie) for number lookup. @keywords phone, trie, prefix_tree, lookup */
 export interface GeoPhoneMap {
-  items: GeoPhoneValue[];
-  info: GeoPhoneValue | undefined;
-  value: string | undefined;
-  mask: string[];
-  maskFull: string[];
-  next: Record<string, 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 */
+/** Result of matching a phone number against the prefix tree. @keywords phone, lookup, result, match */
 export interface GeoPhoneMapInfo {
-  item?: GeoPhoneMap;
-  phone?: string;
+    item?: GeoPhoneMap;
+    phone?: string;
 }
 
 export declare enum MetaTag {
@@ -1881,34 +2121,44 @@ export type HighlightMatchItem = {
 };
 
 export type SortDir = 'asc' | 'desc';
+/** Column sort specification. @keywords sort, column, order */
 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;
+/** Custom comparator function for sorting items. @keywords sort, comparator, sort-function */
+export type SortFunction<T = Record<string, unknown>> = (a: T, b: T, column?: string, dir?: SortDir) => number;
 
-/** Translation plugin configuration options @keywords i18n, translate, config, options */
+/** Configuration options for the translation plugin. @keywords 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 */
+/** Map of translation codes to their localized string values. @keywords translate, list, mapping */
 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 */
+/** Resolves return type to a single translated string or a mapped dictionary. @keywords translate, conditional */
 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 type TranslatePromiseItem = {
+    id: number;
+    promise: Promise<TranslateDataFileList | undefined>;
+};
+/** Translation batch queued for retrieval by locale and language. @keywords translate, batch, queue */
+export interface TranslateBatch {
+    readonly location: string;
+    readonly language: string;
+    readonly path: string;
+    readonly codes: string[];
+    readonly resolves: (() => void)[];
+}
+/** Prefix for global translation keys. @keywords translate, prefix, global */
 export declare const TRANSLATE_GLOBAL_PREFIX = "global";
-/** Batch loading request timeout in milliseconds @keywords i18n, timeout, batch */
+/** Request debounce timeout in milliseconds for batch translation loading. @keywords translate, timeout, debounce */
 export declare const TRANSLATE_TIME_OUT = 160;
 ```