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