1) All these methods are in the @dxtmisha/functional-basic library.
2) Everything that is exported can be used.
3) Use what is in this library if it exists; do not use other libraries if there is an analogue here. Do not create new ones if an analogue already exists here.

The following is the content of "exports" from package.json:
{
  ".": {
    "import": "./dist/library.js",
    "types": "./dist/library.d.ts"
  },
  "./ai-types": "./ai-types.txt",
  "./style": "./dist/style.css",
  "./types/*": "./dist/*",
  "./types/**/*.d.ts": "./dist/**/*.d.ts"
}

// File: classes/Api.d.ts
/**
 * Class for working with HTTP requests.
 */
export declare class Api {
    /**
     * Checks if server is running on localhost.
     * @returns true if local
     */
    static isLocalhost(): boolean;
    /**
     * Returns ApiInstance singleton.
     * @returns ApiInstance singleton
     */
    static getItem(): ApiInstance;
    /**
     * Returns status of the last request.
     * @returns ApiStatus instance
     */
    static getStatus(): ApiStatus;
    /**
     * Gets response handler.
     * @returns ApiResponse instance
     */
    static getResponse(): ApiResponse;
    /**
     * Gets hydration handler.
     * @returns ApiHydration instance
     */
    static getHydration(): ApiHydration;
    /**
     * Returns hydration data script for client.
     * @returns HTML script string
     */
    static getHydrationScript(): string;
    /**
     * Gets base origin URL with API path.
     * @returns final base URL
     */
    static getOrigin(): string;
    /**
     * Gets full path to request script.
     * @param path script path
     * @param api prepend base API URL
     * @returns full URL
     */
    static getUrl(path: string, api?: boolean): string;
    /**
     * Gets data for request body.
     * @param request request data
     * @param method HTTP method
     * @returns body data or FormData
     */
    static getBody(request?: ApiFetch['request'], method?: ApiMethodItem): string | FormData | undefined;
    /**
     * Gets query string for GET requests.
     * @param request request data
     * @param path request path
     * @param method HTTP method
     * @returns query string
     */
    static getBodyForGet(request: ApiFetch['request'], path?: string, method?: ApiMethodItem): string;
    /**
     * Modifies default header data.
     * @param headers default headers
     */
    static setHeaders(headers: Record<string, string>): void;
    /**
     * Modifies default request data.
     * @param request default data
     */
    static setRequestDefault(request: Record<string, any>): void;
    /**
     * Changes base path to script.
     * @param url script path
     */
    static setUrl(url: string): void;
    /**
     * Modifies function called before request.
     * @param callback pre-request function
     */
    static setPreparation(callback: (apiFetch: ApiFetch) => Promise<void>): void;
    /**
     * Modifies function called after request.
     * @param callback post-request function
     */
    static setEnd(callback: (query: Response, apiFetch: ApiFetch) => Promise<ApiPreparationEnd>): void;
    /**
     * Changes request timeout.
     * @param timeout ms
     */
    static setTimeout(timeout: number): void;
    /**
     * Changes origin for base URL.
     * @param origin protocol and domain
     */
    static setOrigin(origin: string): void;
    /**
     * Sets multiple API configuration options.
     * @param config config object
     */
    static setConfig(config?: ApiConfig): void;
    /**
     * Executes request with path or configuration.
     * @param pathRequest path or config
     * @returns Promise with response
     */
    static request<T>(pathRequest: string | ApiFetch): Promise<T>;
    /**
     * Sends GET request.
     * @param request fetch config
     * @returns Promise with response
     */
    static get<T>(request: ApiFetch): Promise<T>;
    /**
     * Sends POST request.
     * @param request fetch config
     * @returns Promise with response
     */
    static post<T>(request: ApiFetch): Promise<T>;
    /**
     * Sends PUT request.
     * @param request fetch config
     * @returns Promise with response
     */
    static put<T>(request: ApiFetch): Promise<T>;
    /**
     * Sends PATCH request.
     * @param request fetch config
     * @returns Promise with response
     */
    static patch<T>(request: ApiFetch): Promise<T>;
    /**
     * Sends DELETE request.
     * @param request fetch config
     * @returns Promise with response
     */
    static delete<T>(request: ApiFetch): Promise<T>;
}
// File: classes/ApiCache.d.ts
/**
 * Class for caching API responses.
 */
export declare class ApiCache {
    /**
     * Initializes storage with listeners.
     * @param getListener retrieval mechanism
     * @param setListener saving mechanism
     * @param removeListener deletion mechanism
     * @param cacheStepAgeClearOld requests before cleanup
     */
    static init(getListener: (key: string) => Promise<ApiCacheItem | undefined>, setListener: (key: string, value: ApiCacheItem) => Promise<boolean>, removeListener: (key: string) => Promise<boolean>, cacheStepAgeClearOld?: number): void;
    /**
     * Resets cache and listeners.
     */
    static reset(): void;
    /**
     * Gets data from cache.
     * @param key cache key
     * @returns data or undefined
     */
    static get<T>(key: string): Promise<T | undefined>;
    /**
     * Gets data from cache using fetch options.
     * @param fetch fetch options
     * @returns data or undefined
     */
    static getByFetch<T>(fetch: ApiFetch): Promise<T | undefined>;
    /**
     * Saves data to cache.
     * @param key cache key
     * @param value data
     * @param age age in seconds
     */
    static set<T>(key: string, value: T, age?: number): Promise<void>;
    /**
     * Saves data to cache using fetch options.
     * @param fetch fetch options
     * @param value data
     */
    static setByFetch<T>(fetch: ApiFetch, value: T): Promise<void>;
    /**
     * Removes data from cache.
     * @param key cache key
     */
    static remove(key: string): Promise<void>;
}
// File: classes/ApiDataReturn.d.ts
/**
 * Class for handling data returned from an API request.
 */
export declare class ApiDataReturn<T = any> {
    /**
     * Constructor for ApiDataReturn.
     * @param apiFetch API config
     * @param query response object
     * @param end preparation end data
     */
    constructor(apiFetch: ApiFetch, query: Response, end: ApiPreparationEnd);
    /**
     * Initializes class by reading response.
     */
    init(): Promise<this>;
    /**
     * Returns processed data.
     */
    get(): ApiData<T>;
    /**
     * Returns processed data with status object.
     * @param status API status instance
     */
    getAndStatus(status: ApiStatus): ApiData<T>;
    /**
     * Returns raw data received from API.
     */
    getData(): ApiData<T> | undefined;
}
// File: classes/ApiDefault.d.ts
/**
 * Class for working with default API request data.
 */
export declare class ApiDefault {
    /**
     * Checks if default data exists.
     * @returns true if exists
     */
    is(): boolean;
    /**
     * Gets default request data.
     * @returns data or undefined
     */
    get(): ApiDefaultValue | undefined;
    /**
     * Adds default data to request.
     * @param request request data
     * @returns merged data
     */
    request(request: ApiFetch['request']): ApiFetch['request'];
    /**
     * Sets default request data.
     * @param request default data
     * @returns this
     */
    set(request: ApiDefaultValue): this;
}
// File: classes/ApiHeaders.d.ts
/**
 * Class for managing HTTP request headers.
 */
export declare class ApiHeaders {
    /**
     * Gets headers for request.
     * @param value header list
     * @param type Content-Type value
     * @returns merged headers
     */
    get(value?: Record<string, string> | null, type?: string | undefined | null): Record<string, string> | undefined;
    /**
     * Gets headers based on request type.
     * @param request request data
     * @param value header list
     * @param type Content-Type value
     * @returns merged headers
     */
    getByRequest(request: ApiFetch['request'], value?: Record<string, string> | null, type?: string): Record<string, string> | undefined;
    /**
     * Sets default headers.
     * @param headers default headers
     * @returns this
     */
    set(headers: Record<string, string>): this;
}
// File: classes/ApiHydration.d.ts
/**
 * Class for collecting API data for SSR hydration.
 */
export declare class ApiHydration {
    /**
     * Initializes response with hydration data.
     * @param response API response
     */
    initResponse(response: ApiResponse): void;
    /**
     * Saves response for client-side hydration.
     * @param apiFetch API config
     * @param response API response data
     */
    toClient<T>(apiFetch: ApiFetch, response: T): void;
    /**
     * Returns hydration data string.
     */
    toString(): string;
}
// File: classes/ApiInstance.d.ts
/** Options for the API instance */
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;
};
/**
 * Core class for managing HTTP requests using Fetch.
 */
export declare class ApiInstance {
    /**
     * Constructor
     * @param url base script path
     * @param options instance options
     */
    constructor(url?: string, options?: ApiInstanceOptions);
    /**
     * Checks if server is localhost.
     * @returns true if local
     */
    isLocalhost(): boolean;
    /**
     * Returns last request status.
     * @returns ApiStatus instance
     */
    getStatus(): ApiStatus;
    /**
     * Gets response handler.
     * @returns ApiResponse instance
     */
    getResponse(): ApiResponse;
    /**
     * Gets hydration handler.
     * @returns ApiHydration instance
     */
    getHydration(): ApiHydration;
    /**
     * Gets base URL with API path.
     * @returns final base URL
     */
    getOrigin(): string;
    /**
     * Gets full script path.
     * @param path script path
     * @param api prepend base URL
     * @returns full URL
     */
    getUrl(path: string, api?: boolean): string;
    /**
     * Gets request body data.
     * @param request request data
     * @param method HTTP method
     * @returns body data or FormData
     */
    getBody(request?: ApiFetch['request'], method?: ApiMethod): string | FormData | undefined;
    /**
     * Gets query string for GET requests.
     * @param request request data
     * @param path request path
     * @param method HTTP method
     * @returns query string with prefix
     */
    getBodyForGet(request: ApiFetch['request'], path?: string, method?: ApiMethod): string;
    /**
     * Returns hydration data script string.
     * @returns HTML script string
     */
    getHydrationScript(): string;
    /**
     * Modifies default headers.
     * @param headers default headers
     */
    setHeaders(headers: Record<string, string>): this;
    /**
     * Modifies default request data.
     * @param request default data
     */
    setRequestDefault(request: Record<string, any>): this;
    /**
     * Changes base path to script.
     * @param url script path
     */
    setUrl(url: string): this;
    /**
     * Sets pre-request function.
     * @param callback pre-request function
     */
    setPreparation(callback: (apiFetch: ApiFetch) => Promise<void>): this;
    /**
     * Sets post-request function.
     * @param callback post-request function
     */
    setEnd(callback: (query: Response, apiFetch: ApiFetch) => Promise<ApiPreparationEnd>): this;
    /**
     * Changes request timeout.
     * @param timeout ms
     */
    setTimeout(timeout: number): this;
    /**
     * Changes origin for base URL.
     * @param origin protocol and domain
     */
    setOrigin(origin: string): this;
    /**
     * Executes request.
     * @param pathRequest path or config
     * @returns Promise with response
     */
    request<T>(pathRequest: string | ApiFetch): Promise<T>;
    /**
     * Sends GET request.
     * @param request fetch config
     * @returns Promise with response
     */
    get<T>(request: ApiFetch): Promise<T>;
    /**
     * Sends POST request.
     * @param request fetch config
     * @returns Promise with response
     */
    post<T>(request: ApiFetch): Promise<T>;
    /**
     * Sends PUT request.
     * @param request fetch config
     * @returns Promise with response
     */
    put<T>(request: ApiFetch): Promise<T>;
    /**
     * Sends PATCH request.
     * @param request fetch config
     * @returns Promise with response
     */
    patch<T>(request: ApiFetch): Promise<T>;
    /**
     * Sends DELETE request.
     * @param request fetch config
     * @returns Promise with response
     */
    delete<T>(request: ApiFetch): Promise<T>;
}
// File: classes/ApiPreparation.d.ts
/**
 * Class for preparing requests.
 */
export declare class ApiPreparation {
    /**
     * Pre-request preparation.
     * @param active is active
     * @param apiFetch request options
     */
    make(active: boolean, apiFetch: ApiFetch): Promise<void>;
    /**
     * Post-request analysis.
     * @param active is active
     * @param query response data
     * @param apiFetch request options
     * @returns end data
     */
    makeEnd(active: boolean, query: Response, apiFetch: ApiFetch): Promise<ApiPreparationEnd>;
    /**
     * Sets pre-request callback.
     * @param callback pre-request function
     * @returns this
     */
    set(callback: (apiFetch: ApiFetch) => Promise<void>): this;
    /**
     * Sets post-request callback.
     * @param callback post-request function
     * @returns this
     */
    setEnd(callback: (query: Response, apiFetch: ApiFetch) => Promise<ApiPreparationEnd>): this;
}
// File: classes/ApiResponse.d.ts
/**
 * Class for working with API responses.
 */
export declare class ApiResponse {
    /**
     * Constructor
     * @param requestDefault default request class
     */
    constructor(requestDefault: ApiDefault);
    /**
     * Gets global cached request if exists.
     * @param path request link
     * @param method request method
     * @param request request data
     * @param devMode dev mode flag
     * @returns cached item or undefined
     */
    get(path: string | undefined, method: ApiMethod, request?: ApiFetch['request'], devMode?: boolean): ApiResponseItem | undefined;
    /**
     * Returns list of cached responses.
     */
    getList(): (ApiResponseItem & Record<string, any>)[];
    /**
     * Adds cached requests.
     * @param response caching data
     */
    add(response: ApiResponseItem | ApiResponseItem[]): this;
    /**
     * Sets developer mode.
     * @param devMode is dev mode
     * @returns this
     */
    setDevMode(devMode: boolean): this;
    /**
     * Executes emulator if available.
     * @param apiFetch fetch config
     * @returns response or undefined
     */
    emulator<T>(apiFetch: ApiFetch): Promise<T | undefined>;
    /**
     * Executes emulator synchronously.
     * @param apiFetch fetch config
     * @returns response or undefined
     */
    emulatorAsync<T>(apiFetch: ApiFetch): T | undefined;
}
// File: classes/ApiStatus.d.ts
/**
 * Class for managing API request status.
 */
export declare class ApiStatus {
    /**
     * Returns last status item.
     * @returns status item or undefined
     */
    get(): ApiStatusItem | undefined;
    /**
     * Returns status code.
     * @returns HTTP status code
     */
    getStatus(): number | undefined;
    /**
     * Returns status text.
     * @returns status text
     */
    getStatusText(): string | undefined;
    /**
     * Returns last status type.
     * @returns status type
     */
    getStatusType(): ApiStatusType | undefined;
    /**
     * Returns execution status code.
     * @returns code
     */
    getCode(): string | undefined;
    /**
     * Returns execution error.
     * @returns error message
     */
    getError(): string | undefined;
    /**
     * Returns last request data.
     * @returns response data
     */
    getResponse<T>(): T | undefined;
    /**
     * Returns last request message.
     * @returns message string
     */
    getMessage(): string;
    /**
     * Sets status item.
     * @param data status data
     * @returns this
     */
    set(data: ApiStatusItem): this;
    /**
     * Sets status code and text.
     * @param status code
     * @param statusText text
     * @returns this
     */
    setStatus(status?: number, statusText?: string): this;
    /**
     * Sets error message.
     * @param error error message
     * @returns this
     */
    setError(error?: string): this;
    /**
     * Sets last response and extracts status/message.
     * @param response response data
     * @returns this
     */
    setLastResponse(response?: any): this;
    /**
     * Sets last status.
     * @param status status
     * @returns this
     */
    setLastStatus(status?: ApiStatusType): this;
    /**
     * Sets last execution code.
     * @param code code
     * @returns this
     */
    setLastCode(code?: string): this;
    /**
     * Sets last request message.
     * @param message text
     * @returns this
     */
    setLastMessage(message?: string): this;
}
// File: classes/BroadcastMessage.d.ts
/**
 * Class for BroadcastChannel messages.
 */
export declare class BroadcastMessage<Message = any> {
    /**
     * Constructor initializing channel with handlers.
     * @param name channel ID
     * @param callback message callback
     * @param callbackError error callback
     * @param errorCenter ErrorCenter instance
     */
    constructor(name: string, callback?: ((event: MessageEvent<Message>) => void) | undefined, callbackError?: ((event: MessageEvent<Message>) => void) | undefined, errorCenter?: ErrorCenterInstance);
    /**
     * Gets BroadcastChannel instance.
     * @returns channel or undefined
     */
    getChannel(): BroadcastChannel | undefined;
    /**
     * Sends message.
     * @param message data
     * @returns this
     */
    post(message: Message): this;
    /**
     * Sets message callback.
     * @param callback callback function
     * @returns this
     */
    setCallback(callback: (event: MessageEvent<Message>) => void): this;
    /**
     * Sets error callback.
     * @param callbackError error function
     * @returns this
     */
    setCallbackError(callbackError: (event: MessageEvent<Message>) => void): this;
    /**
     * Closes channel.
     * @returns this
     */
    destroy(): this;
}
// File: classes/Cache.d.ts
/**
 * Simple in-memory cache for computed values.
 * @deprecated obsolete
 */
export declare class Cache {
    /**
     * Returns cached value. Recomputes if missing.
     * @param name cache key
     * @param callback computation function
     * @param comparison invalidation array
     * @returns value
     */
    get<T>(name: string, callback: () => T, comparison?: any[]): T;
    /**
     * Async returns cached value.
     * @param name cache key
     * @param callback async computation
     * @param comparison invalidation array
     * @returns Promise with value
     */
    getAsync<T>(name: string, callback: () => T, comparison?: any[]): Promise<T>;
}
// File: classes/CacheItem.d.ts
/**
 * Manages single cached value with dependency tracking.
 * @deprecated obsolete
 */
export declare class CacheItem<T> {
    /**
     * Creates CacheItem instance.
     * @param callback computation function
     */
    constructor(callback: () => T);
    /**
     * Returns cached value. Recomputes on dependency change.
     * @param comparison dependency array
     * @returns value
     */
    getCache(comparison: any[]): T;
    /**
     * Returns previous cached value.
     * @returns old value or undefined
     */
    getCacheOld(): T | undefined;
    /**
     * Async returns cached value.
     * @param comparison dependency array
     * @returns Promise with value
     */
    getCacheAsync(comparison: any[]): Promise<T>;
}
// File: classes/CacheStatic.d.ts
/**
 * Static cache using ServerStorage.
 * @deprecated obsolete
 */
export declare class CacheStatic {
    /**
     * Returns cached value.
     * @param name cache key
     * @param callback computation function
     * @param comparison invalidation array
     * @returns value
     */
    static get<T>(name: string, callback: () => T, comparison?: any[]): T;
    /**
     * Async returns cached value.
     * @param name cache key
     * @param callback async computation
     * @param comparison invalidation array
     * @returns Promise with value
     */
    static getAsync<T>(name: string, callback: () => T, comparison?: any[]): Promise<T>;
}
// File: classes/Cookie.d.ts
/**
 * Class for managing cookies.
 */
export declare class Cookie<T> {
    /**
     * Returns instance by cookie name.
     * @param name cookie name
     */
    static getInstance<T>(name: string): Cookie<unknown>;
    /**
     * Constructor
     * @param name cookie name
     */
    constructor(name: string);
    /**
     * Get or update cookie data.
     * @param defaultValue initial value or factory
     * @param options cookie parameters
     * @returns value
     */
    get(defaultValue?: T | string | (() => (T | string)), options?: CookieOptions): string | T | undefined;
    /**
     * Updates cookie.
     * @param value new value or factory
     * @param options cookie parameters
     */
    set(value?: T | string | (() => (T | string)), options?: CookieOptions): void;
    /**
     * Deletes cookie.
     */
    remove(): void;
}
// File: classes/CookieBlock.d.ts
/**
 * Class for cookie access status.
 */
export declare class CookieBlock {
    /**
     * Returns isolated CookieBlockInstance.
     * @returns instance
     */
    static getItem(): CookieBlockInstance;
    /**
     * Gets status.
     * @returns current block status
     */
    static get(): boolean;
    /**
     * Sets status.
     * @param value block status
     */
    static set(value: boolean): void;
}
// File: classes/CookieBlockInstance.d.ts
/**
 * Class for cookie access status.
 */
export declare class CookieBlockInstance {
    /**
     * Gets status.
     * @returns current block status
     */
    get(): boolean;
    /**
     * Sets status.
     * @param value block status
     */
    set(value: boolean): void;
}
// File: classes/CookieStorage.d.ts
/** Cookie sameSite attribute */
export type CookieSameSite = 'strict' | 'lax';
/** Cookie options */
export type CookieOptions = {
    age?: number;
    sameSite?: CookieSameSite;
    path?: string;
    domain?: string;
    secure?: boolean;
    httpOnly?: boolean;
    partitioned?: boolean;
    arguments?: string[] | Record<string, string | number | boolean>;
};
/**
 * Consistent cookie storage across environments.
 */
export declare class CookieStorage {
    /**
     * Initializes storage with listeners.
     */
    static init(getListener?: (key: string) => any | undefined, getListenerRaw?: () => string, setListener?: (key: string, value: any, cookie: string, options?: CookieOptions) => void): void;
    /**
     * Resets storage.
     */
    static reset(): void;
    /**
     * Gets data from storage.
     * @param name cookie name
     * @param defaultValue default value
     * @returns value or default
     */
    static get<T>(name: string, defaultValue?: T | (() => T)): T | undefined;
    /**
     * Saves data to storage.
     * @param name cookie name
     * @param value data or factory
     * @param options parameters
     * @returns saved value
     */
    static set<T>(name: string, value: T | (() => T), options?: CookieOptions): T;
    /**
     * Removes data from storage.
     * @param name cookie name
     */
    static remove(name: string): void;
    /**
     * Updates storage from cookies.
     */
    static update(): void;
}
// File: classes/DataStorage.d.ts
/**
 * Local/session storage wrapper with SSR isolation.
 */
export declare class DataStorage<T> {
    /**
     * Changes key prefix.
     * @param newPrefix prefix
     */
    static setPrefix(newPrefix: string): void;
    /**
     * Constructor.
     * @param name value name
     * @param isSession use session storage
     * @param errorCenter error center instance
     */
    constructor(name: string, isSession?: boolean, errorCenter?: ErrorCenterInstance);
    /**
     * Gets storage data.
     * @param defaultValue default value
     * @param cache cache seconds
     * @returns value or default
     */
    get(defaultValue?: T | (() => T), cache?: number): T | undefined;
    /**
     * Changes storage data.
     * @param value new values
     * @returns set value
     */
    set(value?: T | (() => T)): T | undefined;
    /**
     * Removes storage data.
     * @returns this
     */
    remove(): this;
    /**
     * Syncs from storage.
     * @returns this
     */
    update(): this;
}
// File: classes/Datetime.d.ts
/**
 * Class for working with dates.
 * @remarks Creating instance without specific date in SSR can cause hydration mismatch.
 */
export declare class Datetime {
    /**
     * Constructor
     * @param date date value
     * @param type output format type
     * @param code locale code
     */
    constructor(date?: NumberOrStringOrDate, type?: GeoDate, code?: string);
    /**
     * Returns GeoIntl object.
     * @returns GeoIntl
     */
    getIntl(): GeoIntl;
    /**
     * Returns Date object.
     * @returns Date
     */
    getDate(): Date;
    /**
     * Returns output type.
     * @returns GeoDate
     */
    getType(): GeoDate;
    /**
     * Returns hour format.
     * @returns GeoHours
     */
    getHoursType(): GeoHours;
    /**
     * Checks for 24-hour format.
     * @returns boolean
     */
    getHour24(): boolean;
    /**
     * Returns local time zone offset.
     * @returns offset in minutes
     */
    getTimeZoneOffset(): number;
    /**
     * Returns time zone string.
     * @param style display style
     * @returns time zone
     */
    getTimeZone(style?: GeoTimeZoneStyle): string;
    /**
     * Returns first day of week code.
     * @returns GeoFirstDay
     */
    getFirstDayCode(): GeoFirstDay;
    /**
     * Returns year.
     */
    getYear(): number;
    /**
     * Returns month (1-12).
     */
    getMonth(): number;
    /**
     * Returns day of month (1-31).
     */
    getDay(): number;
    /**
     * Returns hours (0-23).
     */
    getHour(): number;
    /**
     * Returns minutes (0-59).
     */
    getMinute(): number;
    /**
     * Returns seconds (0-59).
     */
    getSecond(): number;
    /**
     * Returns last day of month.
     */
    getMaxDay(): number;
    /**
     * Returns formatted locale date string.
     */
    locale(type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions): string;
    /** Returns formatted year. */
    localeYear(style?: Intl.DateTimeFormatOptions['year']): string;
    /** Returns formatted month. */
    localeMonth(style?: Intl.DateTimeFormatOptions['month']): string;
    /** Returns formatted day. */
    localeDay(style?: Intl.DateTimeFormatOptions['day']): string;
    /** Returns formatted hour. */
    localeHour(style?: Intl.DateTimeFormatOptions['hour']): string;
    /** Returns formatted minute. */
    localeMinute(style?: Intl.DateTimeFormatOptions['minute']): string;
    /** Returns formatted second. */
    localeSecond(style?: Intl.DateTimeFormatOptions['second']): string;
    /** Standard data output string. */
    standard(timeZone?: boolean): string;
    /** Sets date value. */
    setDate(value: NumberOrStringOrDate): this;
    /** Sets output type. */
    setType(value: GeoDate): this;
    /** Sets 24-hour format. */
    setHour24(value: boolean): this;
    /** Sets location code. */
    setCode(code: string): this;
    /** Sets update listener. */
    setWatch(watch: (date: Date, type: GeoDate, hour24: boolean) => void): this;
    /** Sets year. */
    setYear(value: number): this;
    /** Sets month (1-12). */
    setMonth(value: number): this;
    /** Sets day of month. */
    setDay(value: number): this;
    /** Sets hours. */
    setHour(value: number): this;
    /** Sets minutes. */
    setMinute(value: number): this;
    /** Sets seconds. */
    setSecond(value: number): this;
    /** Shifts date by years. */
    moveByYear(value: number): this;
    /** Shifts date by months. */
    moveByMonth(value: number): this;
    /** Shifts date by days. */
    moveByDay(value: number): this;
    /** Shifts date by hours. */
    moveByHour(value: number): this;
    /** Shifts date by minutes. */
    moveByMinute(value: number): this;
    /** Shifts date by seconds. */
    moveBySecond(value: number): this;
    /** Sets date to January. */
    moveMonthFirst(): this;
    /** Sets date to December. */
    moveMonthLast(): this;
    /** Moves to next month first day. */
    moveMonthNext(): this;
    /** Moves to previous month first day. */
    moveMonthPrevious(): this;
    /** Moves to first day of week. */
    moveWeekdayFirst(): this;
    /** Moves to last day of week. */
    moveWeekdayLast(): this;
    /** Moves to first day of first week of month. */
    moveWeekdayFirstByMonth(): this;
    /** Moves to first day of first full week of following month. */
    moveWeekdayLastByMonth(): this;
    /** Moves to next week. */
    moveWeekdayNext(): this;
    /** Moves to previous week. */
    moveWeekdayPrevious(): this;
    /** Moves to first day of month. */
    moveDayFirst(): this;
    /** Moves to last day of month. */
    moveDayLast(): this;
    /** Moves to next day. */
    moveDayNext(): this;
    /** Moves to previous day. */
    moveDayPrevious(): this;
    /** Clones Date object. */
    clone(): Date;
    /** Clones Datetime instance. */
    cloneClass(): Datetime;
    /** Clones and sets month to Jan. */
    cloneMonthFirst(): Datetime;
    /** Clones and sets month to Dec. */
    cloneMonthLast(): Datetime;
    /** Clones and moves 1 month ahead. */
    cloneMonthNext(): Datetime;
    /** Clones and moves 1 month back. */
    cloneMonthPrevious(): Datetime;
    /** Clones and sets to first day of week. */
    cloneWeekdayFirst(): Datetime;
    /** Clones and sets to last day of week. */
    cloneWeekdayLast(): Datetime;
    /** Clones and sets to first day of week in current month. */
    cloneWeekdayFirstByMonth(): Datetime;
    /** Clones and sets to last day of week in current month. */
    cloneWeekdayLastByMonth(): Datetime;
    /** Clones and sets to next week. */
    cloneWeekdayNext(): Datetime;
    /** Clones and sets to previous week. */
    cloneWeekdayPrevious(): Datetime;
    /** Clones and moves to beginning of month. */
    cloneDayFirst(): Datetime;
    /** Clones and moves to end of month. */
    cloneDayLast(): Datetime;
    /** Clones and moves 1 day ahead. */
    cloneDayNext(): Datetime;
    /** Clones and moves 1 day back. */
    cloneDayPrevious(): Datetime;
}
// File: classes/ErrorCenter.d.ts
/**
 * Class for managing error storage and handling.
 */
export declare class ErrorCenter {
    /** Returns request-isolated ErrorCenterInstance. */
    static getItem(): ErrorCenterInstance;
    /** Checks if cause with code exists. */
    static has(code: string, group?: string): boolean;
    /** Gets error cause by code and group. */
    static get(code: string, group?: string): ErrorCenterCauseItem | undefined;
    /** Adds error cause. */
    static add(cause: ErrorCenterCauseItem): void;
    /** Adds list of error causes. */
    static addList(causes: ErrorCenterCauseList): void;
    /** Registers new handler. */
    static addHandler(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): void;
    /** Registers list of handlers. */
    static addHandlerList(handlers: ErrorCenterHandlerList): void;
    /** Triggers error handling. */
    static on(cause: ErrorCenterCauseItem): void;
}
// File: classes/ErrorCenterHandler.d.ts
/**
 * Class for managing and triggering error handlers.
 */
export declare class ErrorCenterHandler {
    /** Constructor */
    constructor(handlers?: ErrorCenterHandlerList);
    /** Checks for handlers in group. */
    has(group: ErrorCenterGroup): boolean;
    /** Gets handlers for group. */
    get(group: ErrorCenterGroup): ErrorCenterHandlerItem | undefined;
    /** Adds handler for group. */
    add(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this;
    /** Adds list of handlers. */
    addList(handlers: ErrorCenterHandlerList): this;
    /** Triggers handlers and logs error. */
    on(cause: ErrorCenterCauseItem): this;
}
// File: classes/ErrorCenterInstance.d.ts
/**
 * Instance-based error storage and handling.
 */
export declare class ErrorCenterInstance {
    /** Constructor */
    constructor(causes?: ErrorCenterCauseList, handler?: ErrorCenterHandler);
    /** Checks for cause by code. */
    has(code: string, group?: string): boolean;
    /** Gets cause by code. */
    get(code: string, group?: string): ErrorCenterCauseItem | undefined;
    /** Adds error cause. */
    add(cause: ErrorCenterCauseItem): this;
    /** Adds causes list. */
    addList(causes: ErrorCenterCauseList): this;
    /** Registers handler. */
    addHandler(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this;
    /** Registers handlers list. */
    addHandlerList(handlers: ErrorCenterHandlerList): this;
    /** Triggers error handling. */
    on(cause: ErrorCenterCauseItem): this;
}
// File: classes/EventItem.d.ts
/**
 * Advanced wrapper for managing event listeners.
 * 
 * ### Key Features:
 * - **Lifecycle Control**: `start`, `stop`, `toggle`, `reset`.
 * - **DOM Safety**: Automatically halts if element removed.
 * - **Optimizations**: `resize` via `ResizeObserver`, `scroll-sync` via `requestAnimationFrame`.
 * 
 * ### Usage Examples:
 * @example
 * const clickEvent = new EventItem('.btn', 'click', () => console.log('OK'));
 * clickEvent.start();
 * @example
 * interface UserData { id: number }
 * const emitter = new EventItem<Window, CustomEvent, UserData>(window, 'update');
 * emitter.setListener((e, detail) => console.log(detail?.id));
 * emitter.start();
 * emitter.dispatch({ id: 123 });
 */
export declare class EventItem<E extends ElementOrWindow, O extends Event, D extends Record<string, any> = Record<string, any>> {
    /**
     * Constructor
     * @param elementSelector target element or selector
     * @param type event type or types array
     * @param listener handler function
     * @param options standard options or capture flag
     * @param detail custom data for listener
     */
    constructor(elementSelector?: ElementOrString<E>, type?: string | string[], listener?: EventListenerDetail<O, D> | undefined, options?: EventOptions, detail?: D | undefined);
    /** Checks if listening is active. */
    isActive(): boolean;
    /** Returns target element. */
    getElement(): E | undefined;
    /** Changes target element. */
    setElement(elementSelector?: ElementOrString<E>): this;
    /** Modifies safety check element. */
    setElementControl<EC extends HTMLElement>(elementSelector?: ElementOrString<EC>): this;
    /** Changes event type. */
    setType(type: string | string[]): this;
    /** Modifies listener. */
    setListener(listener: EventListenerDetail<O, D>): this;
    /** Modifies options. */
    setOptions(options?: EventOptions): this;
    /** Modifies detail data. */
    setDetail(detail?: D): this;
    /** Manually triggers custom event dispatch. */
    dispatch(detail?: D | undefined): this;
    /** Starts listening. */
    start(): this;
    /** Stops listening. */
    stop(): this;
    /** Toggles state. */
    toggle(activity: boolean): this;
    /** Resets (stop and start if active). */
    reset(): this;
}
// File: classes/Formatters.d.ts
/**
 * Formats data list based on options.
 */
export declare class Formatters<Options extends FormattersOptionsList = FormattersOptionsList, List extends FormattersListProp = FormattersListProp, Item extends FormattersItemProp<List> = FormattersItemProp<List>> {
    /**
     * Constructor
     * @param options formatting configuration
     * @param list data list
     */
    constructor(options: Options, list?: List | undefined);
    /** Checks if list set. */
    is(): boolean;
    /** Checks if list is array. */
    isArray(): this is this & { list: FormattersList<Item>; };
    /** Returns record count. */
    length(): number;
    /** Returns array list. */
    getList(): FormattersList<Item>;
    /** Returns options. */
    getOptions(): Options;
    /** Sets data list. */
    setList(list?: List): this;
    /** Formats data. Adds values with 'Format' suffix. */
    to(): FormattersReturn<List, Options>;
}
// File: classes/Geo.d.ts
/**
 * Static geographic data management.
 */
export declare class Geo {
    /** Returns request-isolated GeoInstance. */
    static getObject(): GeoInstance;
    /** Returns current country and language. */
    static get(): GeoItemFull;
    /** Returns 2-letter country code. */
    static getCountry(): string;
    /** Returns 2-letter language code. */
    static getLanguage(): string;
    /** Returns 'en-US' style locale. */
    static getStandard(): string;
    /** Returns first day code. */
    static getFirstDay(): string;
    /** Returns location string. */
    static getLocation(): string;
    /** Returns processed geo data. */
    static getItem(): GeoItemFull;
    /** Returns countries list. */
    static getList(): GeoItem[];
    /** Gets data by code. */
    static getByCode(code?: string): GeoItemFull;
    /** Search by full locale match. */
    static getByCodeFull(code: string): GeoItem | undefined;
    /** Search by country code. */
    static getByCountry(country: string): GeoItem | undefined;
    /** Search by language code. */
    static getByLanguage(language: string): GeoItem | undefined;
    /** Returns timezone offset. */
    static getTimezone(): number;
    /** Returns formatted timezone ('+00:00'). */
    static getTimezoneFormat(): string;
    /** Determine geo data for code. */
    static find(code: string): GeoItemFull;
    /** Returns 'en-US' string from item. */
    static toStandard(item: GeoItem): string;
    /** Sets location. */
    static set(code: string, save?: boolean): void;
    /** Sets timezone offset. */
    static setTimezone(timezone: number): void;
}
// File: classes/GeoFlag.d.ts
export declare const GEO_FLAG_ICON_NAME = "f";
/**
 * Manage flags and geographic info.
 */
export declare class GeoFlag {
    static flags: Record<string, string>;
    /** Constructor */
    constructor(code?: string);
    /** Gets country info and flag. */
    get(code?: string): GeoFlagItem | undefined;
    /** Gets flag icon ID. */
    getFlag(code?: string): string | undefined;
    /** Returns countries list. */
    getList(codes?: string[]): GeoFlagItem[];
    /** Returns list with national names. */
    getNational(codes?: string[]): GeoFlagNational[];
    /** Changes locale. */
    setCode(code: string): this;
}
// File: classes/GeoInstance.d.ts
/**
 * Base class for geographic data.
 */
export declare class GeoInstance {
    constructor();
    /** Gets current country info. */
    get(): GeoItemFull;
    /** Gets country code. */
    getCountry(): string;
    /** Gets language code. */
    getLanguage(): string;
    /** Gets language-country format. */
    getStandard(): string;
    /** Gets first day of week. */
    getFirstDay(): string;
    /** Gets location string. */
    getLocation(): string;
    /** Gets processed data. */
    getItem(): GeoItemFull;
    /** Returns countries list. */
    getList(): GeoItem[];
    /** Gets data by code. */
    getByCode(code?: string): GeoItemFull;
    /** Gets data by language-country. */
    getByCodeFull(code: string): GeoItem | undefined;
    /** Gets data by country code. */
    getByCountry(country: string): GeoItem | undefined;
    /** Gets data by language code. */
    getByLanguage(language: string): GeoItem | undefined;
    /** Gets offset minutes. */
    getTimezone(): number;
    /** Gets formatted offset string. */
    getTimezoneFormat(): string;
    /** Finds country data by code/name. */
    find(code: string): GeoItemFull;
    /** Converts to standard code. */
    toStandard(item: GeoItem): string;
    /** Updates location. */
    set(code: string, save?: boolean): void;
    /** Updates timezone offset. */
    setTimezone(timezone: number): void;
}
// File: classes/GeoIntl.d.ts
/**
 * Intl wrapper for language-sensitive formatting.
 */
export declare class GeoIntl {
    /** Checks for code instance. */
    static isItem(code?: string): boolean;
    /** Returns location code. */
    static getLocation(code?: string): string;
    /** Returns instance for code. */
    static getInstance(code?: string): GeoIntl;
    /** Constructor */
    constructor(code?: string, errorCenter?: ErrorCenterInstance);
    /** Returns location code. */
    getLocation(): string;
    /** Returns first day. */
    getFirstDay(): string;
    /** Translated names for language/region. */
    display(value?: string, typeOptions?: Intl.DisplayNamesOptions['type'] | Intl.DisplayNamesOptions): string;
    /** Display language name. */
    languageName(value?: string, style?: Intl.RelativeTimeFormatStyle): string;
    /** Display region name. */
    countryName(value?: string, style?: Intl.RelativeTimeFormatStyle): string;
    /** Formatted full name. */
    fullName(last: string, first: string, surname?: string, short?: boolean): string;
    /** Number formatting. */
    number(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
    /** Decimal point symbol. */
    decimal(): string;
    /** Currency formatting. */
    currency(value: NumberOrString, currencyOptions?: string | Intl.NumberFormatOptions, numberOnly?: boolean): string;
    /** Returns currency symbol or code. */
    currencySymbol(currency: string, currencyDisplay?: keyof Intl.NumberFormatOptionsCurrencyDisplayRegistry): string;
    /** Unit formatting. */
    unit(value: NumberOrString, unitOptions?: string | Intl.NumberFormatOptions): string;
    /** File size formatting. */
    sizeFile(value: NumberOrString, unitOptions?: 'byte' | 'kilobyte' | 'megabyte' | 'gigabyte' | 'terabyte' | 'petabyte' | Intl.NumberFormatOptions): string;
    /** Percent formatting. */
    percent(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
    /** Percent formatting (base 100). */
    percentBy100(value: NumberOrString, options?: Intl.NumberFormatOptions): string;
    /** Plural rule formatting. */
    plural(value: NumberOrString, words: string, options?: Intl.PluralRulesOptions, optionsNumber?: Intl.NumberFormatOptions): string;
    /** Date formatting. */
    date(value: NumberOrStringOrDate, type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions, hour24?: boolean): string;
    /** Relative time formatting. */
    relative(value: NumberOrStringOrDate, styleOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions, todayValue?: Date): string;
    /** Relative time with fallback limit. */
    relativeLimit(value: NumberOrStringOrDate, limit: number, todayValue?: Date, relativeOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions, dateOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions, type?: GeoDate, hour24?: boolean): string;
    /** Relative time by specific value and unit. */
    relativeByValue(value: NumberOrString, unit: Intl.RelativeTimeFormatUnit, styleOptions?: Intl.RelativeTimeFormatStyle | Intl.RelativeTimeFormatOptions): string;
    /** Month name. */
    month(value?: NumberOrStringOrDate, style?: Intl.DateTimeFormatOptions['month']): string;
    /** Months list. */
    months(style?: Intl.DateTimeFormatOptions['month']): ItemValue<number | undefined>[];
    /** Weekday name. */
    weekday(value?: NumberOrStringOrDate, style?: Intl.DateTimeFormatOptions['weekday']): string;
    /** Weekdays list. */
    weekdays(style?: Intl.DateTimeFormatOptions['weekday']): ItemValue<number | undefined>[];
    /** Time string. */
    time(value: NumberOrStringOrDate): string;
    /** Locale-sensitive sort. */
    sort<T>(data: T[], compareFn?: (a: T, b: T) => [string, string]): T[];
}
// File: classes/GeoPhone.d.ts
/**
 * Phone number mask storage and processing.
 */
export declare class GeoPhone {
    /** Gets code and country info. */
    static get(code: string): GeoPhoneValue | undefined;
    /** Gets info by phone. */
    static getByPhone(phone: string): GeoPhoneMapInfo;
    /** Gets mask data by country code. */
    static getByCode(code: string): GeoPhoneMap | undefined;
    /** Returns codes list. */
    static getList(): GeoPhoneValue[];
    /** Returns map tree. */
    static getMap(): Record<string, GeoPhoneMap>;
    /** Converts to phone mask. */
    static toMask(phone: string, masks?: string[]): string | undefined;
    /** Removes country code. */
    static removeZero(phone: string): string;
}
// File: classes/Global.d.ts
/**
 * Global application data storage.
 */
export declare class Global {
    /** Returns storage instance. */
    static getItem(): Record<string, any>;
    /** Gets value by name. */
    static get<R = any>(name: string): R;
    /** Adds data once. */
    static add(data: Record<string, any>): void;
}
// File: classes/Hash.d.ts
/**
 * URL hash data management.
 */
export declare class Hash {
    /** Returns HashInstance. */
    static getItem(): HashInstance;
    /** Gets data from hash. */
    static get<T>(name: string, defaultValue?: T | (() => T)): T;
    /** Sets data in hash. */
    static set<T>(name: string, callback: T | (() => T)): void;
    /** Adds change watcher. */
    static addWatch<T>(name: string, callback: (value: T) => void): void;
    /** Removes watcher. */
    static removeWatch<T>(name: string, callback: (value: T) => void): void;
    /** Reloads from URL string. */
    static reload(): void;
}
// File: classes/HashInstance.d.ts
/**
 * URL hash data management.
 */
export declare class HashInstance {
    /** Gets data from hash. */
    get<T>(name: string, defaultValue?: T | (() => T)): T;
    /** Sets data in hash. */
    set<T>(name: string, callback: T | (() => T)): this;
    /** Adds change listener. */
    addWatch<T>(name: string, callback: (value: T) => void): this;
    /** Removes listener. */
    removeWatch<T>(name: string, callback: (value: T) => void): this;
    /** Updates from URL. */
    reload(): this;
}
// File: classes/Icons.d.ts
export type IconsItem = string | Promise<string | any> | (() => Promise<string | any>);
export type IconsConfig = {
    url?: string;
    list?: Record<string, IconsItem>;
};
/**
 * Icons management.
 */
export declare class Icons {
    /** Checks if icon registered. */
    static is(index: string): boolean;
    /** Returns icon content/path. */
    static get(index: string, url?: string, wait?: number): Promise<string>;
    /** Sync returns icon. */
    static getAsync(index: string, url?: string): string;
    /** Returns icon names list. */
    static getNameList(): string[];
    /** Returns global URL. */
    static getUrlGlobal(): string;
    /** Adds custom icon. */
    static add(index: string, file: IconsItem): void;
    /** Adds loading placeholder. */
    static addLoad(index: string): void;
    /** Adds global icon. */
    static addGlobal(index: string, file: string): void;
    /** Adds icons list. */
    static addByList(list: Record<string, IconsItem>): void;
    /** Changes path. */
    static setUrl(url: string): void;
    /** Changes config. */
    static setConfig(config: IconsConfig): void;
}
// File: classes/Loading.d.ts
/**
 * Global loading state.
 */
export declare class Loading {
    /** Checks if active. */
    static is(): boolean;
    /** Gets current value. */
    static get(): number;
    /** Returns LoadingInstance. */
    static getItem(): LoadingInstance;
    /** Shows loader. */
    static show(): void;
    /** Hides loader. */
    static hide(): void;
    /** Registers event listener. */
    static registrationEvent(listener: EventListenerDetail<CustomEvent, LoadingDetail>, element?: ElementOrString<HTMLElement>): void;
    /** Unregisters event listener. */
    static unregistrationEvent(listener: EventListenerDetail<CustomEvent, LoadingDetail>, element?: ElementOrString<HTMLElement>): void;
}
// File: classes/LoadingInstance.d.ts
/** Loading event data */
export type LoadingDetail = {
    loading: boolean;
};
/** Loading registration item */
export type LoadingRegistrationItem = {
    item: EventItem<Window, CustomEvent, LoadingDetail>;
    listener: EventListenerDetail<CustomEvent, LoadingDetail>;
    element?: ElementOrString<HTMLElement>;
};
/**
 * Global loading instance.
 */
export declare class LoadingInstance {
    /** Constructor */
    constructor(eventName?: string);
    /** Checks if loader active. */
    is(): boolean;
    /** Gets loading value. */
    get(): number;
    /** Shows loader. */
    show(): void;
    /** Hides loader. */
    hide(): void;
    /** Registers event. */
    registrationEvent(listener: EventListenerDetail<CustomEvent, LoadingDetail>, element?: ElementOrString<HTMLElement>): void;
    /** Unregisters event. */
    unregistrationEvent(listener: EventListenerDetail<CustomEvent, LoadingDetail>, element?: ElementOrString<HTMLElement>): void;
}
// File: classes/Meta.d.ts
/**
 * Unified meta tag manager (Standard, OG, Twitter).
 */
export declare class Meta extends MetaManager<MetaTag[]> {
    /** Constructor */
    constructor();
    /** Gets MetaOg instance. */
    getOg(): MetaOg;
    /** Gets MetaTwitter instance. */
    getTwitter(): MetaTwitter;
    /** Gets title. */
    getTitle(): string;
    /** Gets keywords. */
    getKeywords(): string;
    /** Gets description. */
    getDescription(): string;
    /** Gets OG image. */
    getImage(): string;
    /** Gets canonical URL. */
    getCanonical(): string;
    /** Gets robots directive. */
    getRobots(): MetaRobots;
    /** Gets author. */
    getAuthor(): string;
    /** Gets OG site name. */
    getSiteName(): string;
    /** Gets OG locale. */
    getLocale(): string;
    /** Sets title and syncs cards. */
    setTitle(title: string): this;
    /** Sets keywords. */
    setKeywords(keywords: string | string[]): this;
    /** Sets description. */
    setDescription(description: string): this;
    /** Sets OG/Twitter image. */
    setImage(image: string): this;
    /** Sets canonical and syncs cards. */
    setCanonical(canonical: string): this;
    /** Sets robots. */
    setRobots(robots: MetaRobots): this;
    /** Sets author. */
    setAuthor(author: string): this;
    /** Sets OG/Twitter site name. */
    setSiteName(siteName: string): this;
    /** Sets OG locale. */
    setLocale(locale: string): this;
    /** Sets title suffix. */
    setSuffix(suffix?: string): void;
    /** Generates full HTML. */
    html(): string;
    /** Generates HTML-safe title. */
    htmlTitle(): string;
}
// File: classes/MetaManager.d.ts
type MetaList<T extends readonly string[]> = {
    [K in T[number]]?: string;
};
/**
 * Base meta tag management.
 */
export declare class MetaManager<T extends readonly string[], Key extends keyof MetaList<T> = keyof MetaList<T>> {
    /**
     * Constructor
     * @param listMeta names list
     * @param isProperty use property attribute
     */
    constructor(listMeta: T, isProperty?: boolean);
    /** Returns tag names list. */
    getListMeta(): T;
    /** Gets content by name. */
    get(name: Key): string;
    /** Returns all tags object. */
    getItems(): MetaList<T>;
    /** Returns all tags HTML. */
    html(): string;
    /** Sets tag content. */
    set(name: Key, content: string): this;
    /** Sets multiple tags. */
    setByList(metaList: MetaList<T>): this;
}
// File: classes/MetaOg.d.ts
/**
 * Open Graph meta manager.
 */
export declare class MetaOg extends MetaManager<MetaOpenGraphTag[]> {
    constructor();
    getTitle(): string;
    getType(): MetaOpenGraphType;
    getUrl(): string;
    getImage(): string;
    getDescription(): string;
    getLocale(): string;
    getSiteName(): string;
    setTitle(title: string): this;
    setType(type: MetaOpenGraphType): this;
    setUrl(url: string): this;
    setImage(url: string): this;
    setDescription(description: string): this;
    setLocale(locale: string): this;
    setSiteName(siteName: string): this;
}
// File: classes/MetaStatic.d.ts
/**
 * Static meta tag management.
 */
export declare class MetaStatic {
    static getItem(): Meta;
    static getOg(): MetaOg;
    static getTwitter(): MetaTwitter;
    static getTitle(): string;
    static getKeywords(): string;
    static getDescription(): string;
    static getImage(): string;
    static getCanonical(): string;
    static getRobots(): MetaRobots;
    static getAuthor(): string;
    static getSiteName(): string;
    static getLocale(): string;
    static setTitle(title: string): typeof MetaStatic;
    static setKeywords(keywords: string | string[]): typeof MetaStatic;
    static setDescription(description: string): typeof MetaStatic;
    static setImage(image: string): typeof MetaStatic;
    static setCanonical(canonical: string): typeof MetaStatic;
    static setRobots(robots: MetaRobots): typeof MetaStatic;
    static setAuthor(author: string): typeof MetaStatic;
    static setSiteName(siteName: string): typeof MetaStatic;
    static setLocale(locale: string): typeof MetaStatic;
    static setSuffix(suffix?: string): typeof MetaStatic;
    static html(): string;
    static htmlTitle(): string;
}
// File: classes/MetaTwitter.d.ts
/**
 * Twitter Card meta manager.
 */
export declare class MetaTwitter extends MetaManager<MetaTwitterTag[]> {
    constructor();
    getCard(): MetaTwitterCard;
    getSite(): string;
    getCreator(): string;
    getUrl(): string;
    getTitle(): string;
    getDescription(): string;
    getImage(): string;
    setCard(card: MetaTwitterCard): this;
    setSite(site: string): this;
    setCreator(creator: string): this;
    setUrl(url: string): this;
    setTitle(title: string): this;
    setDescription(description: string): this;
    setImage(image: string): this;
}
// File: classes/ResumableTimer.d.ts
/**
 * Timer that can be paused/resumed.
 */
export declare class ResumableTimer {
    /**
     * Constructor
     * @param callback function to call
     * @param delay ms
     * @param blockStart no immediate start
     */
    constructor(callback: FunctionVoid, delay?: number, blockStart?: boolean);
    /** Resumes/starts timer. */
    resume(): this;
    /** Pauses timer. */
    pause(): this;
    /** Resets with original delay. */
    reset(): this;
    /** Clears timer state. */
    clear(): this;
}
// File: classes/ScrollbarWidth.d.ts
/**
 * Gets scrollbar width.
 */
export declare class ScrollbarWidth {
    /** Checks if scroll hiding enabled. */
    static is(): Promise<boolean>;
    /** Returns width in pixels. */
    static get(): Promise<number>;
    /** Returns storage instance. */
    static getStorage(): DataStorage<number>;
    /** Checks if calculation active. */
    static getCalculate(): boolean;
}
// File: classes/SearchList.d.ts
/**
 * Manages searchable list.
 */
export declare class SearchList<T extends SearchItem, K extends SearchColumns<T>> {
    /**
     * Constructor
     * @param list data list
     * @param columns search columns
     * @param value initial value
     * @param options search options
     */
    constructor(list: SearchListValue<T>, columns?: K, value?: string, options?: SearchOptions);
    /** Returns data manager. */
    getData(): SearchListData<T, K>;
    /** Returns items list. */
    getList(): SearchListValue<T>;
    /** Returns search columns. */
    getColumns(): K | undefined;
    /** Returns search item instance. */
    getItem(): SearchListItem;
    /** Returns current search value. */
    getValue(): string | undefined;
    /** Returns options manager. */
    getOptions(): SearchListOptions;
    /** Sets items and resets cache. */
    setList(list: SearchListValue<T>): this;
    /** Sets columns and resets cache. */
    setColumns(columns?: K): this;
    /** Sets value and updates matcher. */
    setValue(value?: string): this;
    /** Sets options and updates matcher. */
    setOptions(options: SearchOptions): this;
    /** Processes and returns formatted list. */
    to(): SearchFormatList<T, K>;
}
// File: classes/SearchListData.d.ts
/**
 * Search data and cache manager.
 */
export declare class SearchListData<T extends SearchItem, K extends SearchColumns<T>> {
    /** Constructor */
    constructor(list: SearchListValue<T>, columns: K | undefined, item: SearchListItem, options: SearchListOptions);
    /** Checks if ready for search. */
    is(): this is this & { list: T[]; columns: string[]; };
    /** Checks for list. */
    isList(): this is this & { list: T[]; };
    /** Returns original list. */
    getList(): SearchListValue<T>;
    /** Returns columns. */
    getColumns(): K | undefined;
    /** Sets list and regenerates cache. */
    setList(list: SearchListValue<T>): this;
    /** Sets columns and regenerates cache. */
    setColumns(columns?: SearchColumns<T>): this;
    /** Finds cached item. */
    findCacheItem(item: T): SearchCacheItem<T> | undefined;
    /** Executes callback for each cached item. */
    forEach(callback: (item: SearchCacheItem<T>['item'], value: SearchCacheItem<T>['value']) => SearchFormatItem<T, K> | undefined): SearchFormatList<T, K>;
    /** Formats single item with highlights. */
    toFormatItem(item: T, selection: boolean): SearchFormatItem<T, K>;
}
// File: classes/SearchListItem.d.ts
/**
 * Single search item state.
 */
export declare class SearchListItem {
    /** Constructor */
    constructor(value: string | undefined, options: SearchListOptions);
    /** Checks for value. */
    is(): this is this & { value: string; };
    /** Checks if search should trigger. */
    isSearch(): boolean;
    /** Returns value. */
    get(): string;
    /** Sets value. */
    set(value?: string): this;
}
// File: classes/SearchListMatcher.d.ts
/**
 * Search regex matcher.
 */
export declare class SearchListMatcher {
    /** Constructor */
    constructor(item: SearchListItem, options: SearchListOptions);
    /** Checks if initialized. */
    is(): boolean;
    /** Checks for match. */
    isSelection(value: SearchCacheItem<any>['value']): boolean;
    /** Returns current RegExp. */
    get(): RegExp | undefined;
    /** Updates matcher from value/options. */
    update(): void;
}
// File: classes/SearchListOptions.d.ts
/**
 * Search options manager.
 */
export declare class SearchListOptions {
    /** Constructor */
    constructor(options?: SearchOptions | undefined);
    getOptions(): SearchOptions;
    getLimit(): number;
    getReturnEverything(): boolean;
    getDelay(): number;
    getFindExactMatch(): boolean;
    getClassName(): string;
    setOptions(options: SearchOptions): this;
}
// File: classes/ServerStorage.d.ts
type ServerStorageItem = {
    value: any;
    hydration: boolean;
};
type ServerStorageList = Record<string, ServerStorageItem>;
/**
 * SSR data isolation manager.
 */
export declare class ServerStorage {
    /**
     * Initializes storage with context listener.
     * @param listener context factory
     * @returns this class
     */
    static init(listener: () => Record<string, any> | undefined): typeof ServerStorage;
    static reset(): void;
    /** Checks key existence. */
    static has(key: string): boolean;
    /** Gets value or creates with factory. */
    static get<T = any>(key: string, defaultValue?: () => T, hydration?: boolean): T;
    /** Saves value. */
    static set<T = any>(key: string, value: () => T, hydration?: boolean): T;
    static setErrorStatus(hide: boolean): void;
    static remove(key: string): void;
    /** Returns hydration script string. */
    static toString(): string;
}
// File: classes/StorageCallback.d.ts
/**
 * Callback lists for storage.
 */
export declare class StorageCallback<T = any, Callback = (value: T) => void | Promise<void>> {
    /** Returns instance by name. */
    static getInstance<T>(name: string, group?: string): StorageCallback<T, (value: T) => void | Promise<void>>;
    /** Constructor */
    constructor(name: string, group?: string);
    /** Gets loading state. */
    isLoading(): boolean;
    /** Gets name. */
    getName(): string;
    getLoading(): boolean;
    /** Adds callback. */
    addCallback(callback: Callback, isOnce?: boolean): this;
    /** Removes callback. */
    removeCallback(callback: Callback): this;
    /** Prepares launch. */
    preparation(): this;
    /** Executes all callbacks. */
    run(value: T): Promise<this>;
}
// File: classes/Translate.d.ts
/**
 * Translation text retrieval.
 */
export declare class Translate {
    /** Gets text by code. */
    static get(name: string, replacement?: string[] | Record<string, string | number>): Promise<string>;
    /** Returns TranslateInstance. */
    static getItem(): TranslateInstance;
    /** Sync gets text by code. */
    static getSync(name: string, first?: boolean, replacement?: string[] | Record<string, string | number>): string;
    /** Gets list of translations. */
    static getList<T extends TranslateCode[]>(names: T): Promise<TranslateList<T>>;
    /** Sync gets translations list. */
    static getListSync<T extends TranslateCode[]>(names: T, first?: boolean): TranslateList<T>;
    /** Adds translated texts. */
    static add(names: string | string[]): Promise<void>;
    /** Sync adds texts. */
    static addSync(data: Record<string, string>): void;
    /** Adds based on environment. */
    static addNormalOrSync(data: Record<string, string>): Promise<void>;
    /** Adds sync by location. */
    static addSyncByLocation(data: Record<string, Record<string, string>>): void;
    /** Adds sync from file. */
    static addSyncByFile(data: TranslateDataFile): void;
    /** Sets script URL. */
    static setUrl(url: string): void;
    /** Sets property name. */
    static setPropsName(name: string): void;
    /** Changes read mode. */
    static setReadApi(value: boolean): void;
    /** Sets configuration. */
    static setConfig(config: TranslateConfig): void;
}
// File: classes/TranslateFile.d.ts
/**
 * Translation files manager.
 */
export declare class TranslateFile {
    /** Constructor */
    constructor(data?: TranslateDataFile, language?: string | (() => string), location?: string | (() => string));
    /** Checks for files. */
    isFile(): boolean;
    /** Gets location. */
    getLocation(): string;
    /** Gets language. */
    getLanguage(): string;
    /** Returns translations list. */
    getList(): Promise<TranslateDataFileList | undefined>;
    /** Adds files list. */
    add(data: TranslateDataFile): void;
}
// File: classes/TranslateInstance.d.ts
/**
 * Translation text retrieval instance.
 */
export declare class TranslateInstance {
    /** Constructor */
    constructor(url?: string, propsName?: string, files?: TranslateFile);
    /** Gets text by code. */
    get(name: string, replacement?: string[] | Record<string, string | number>): Promise<string>;
    /** Sync gets text. */
    getSync(name: string, first?: boolean, replacement?: string[] | Record<string, string | number>): string;
    /** Gets translations list. */
    getList<T extends TranslateCode[]>(names: T): Promise<TranslateList<T>>;
    /** Sync gets list. */
    getListSync<T extends TranslateCode[]>(names: T, first?: boolean): TranslateList<T>;
    /** Adds texts. */
    add(names: string | string[]): Promise<void>;
    /** Sync adds texts. */
    addSync(data: Record<string, string>): void;
    /** Environment-based add. */
    addNormalOrSync(data: Record<string, string>): Promise<void>;
    /** Sync add by location. */
    addSyncByLocation(data: Record<string, Record<string, string>>): void;
    /** Sync add from file. */
    addSyncByFile(data: TranslateDataFile): void;
    /** Sets script URL. */
    setUrl(url: string): this;
    /** Sets property name. */
    setPropsName(name: string): this;
    /** Sets read mode. */
    setReadApi(value: boolean): this;
}
// File: functions/addTagHighlightMatch.d.ts
/** Highlights match in string with tags. */
export declare function addTagHighlightMatch(value: string, search?: string | RegExp, className?: string, shouldEscape?: boolean): string;
// File: functions/anyToString.d.ts
/** Converts any value to string. */
export declare function anyToString<V>(value: V, isArrayString?: boolean, trim?: boolean): string;
// File: functions/applyTemplate.d.ts
/** Replaces template keys [key] or {key} with values. */
export declare const applyTemplate: (text: string, replacement?: Record<string, string | number | boolean> | string[]) => string;
// File: functions/arrFill.d.ts
/** Creates array of length count filled with value. */
export declare function arrFill<T>(value: T, count: number): T[];
// File: functions/blobToBase64.d.ts
/** Converts Blob to Base64. */
export declare function blobToBase64(blob: Blob, clean?: boolean): Promise<string | undefined>;
// File: functions/capitalize.d.ts
/** Capitalizes first letter. */
export declare function capitalize(value: string, isLocale?: boolean): string;
// File: functions/copyObject.d.ts
/** Deep copy of object. */
export declare function copyObject<T>(value: T): T;
// File: functions/copyObjectLite.d.ts
/** Shallow copy of simple object. */
export declare function copyObjectLite<T, R = T>(value: T, source?: any): R;
// File: functions/createElement.d.ts
/**
 * Creates HTML element.
 * @remarks Client-side only. Returns undefined in SSR.
 */
export declare function createElement<T extends HTMLElement>(parentElement?: HTMLElement, tagName?: string, options?: Partial<T> | Record<keyof T, T[keyof T]> | ((element: T) => void), referenceElement?: HTMLElement): T | undefined;
// File: functions/domQuerySelector.d.ts
/** Returns first matched element. */
export declare function domQuerySelector<E extends Element = Element>(selectors: string): E | undefined;
// File: functions/domQuerySelectorAll.d.ts
/** Returns all matched elements. */
export declare function domQuerySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E> | undefined;
// File: functions/encodeAttribute.d.ts
/** Encodes for HTML attributes. */
export declare function encodeAttribute(text: string): string;
// File: functions/encodeLiteAttribute.d.ts
/** Lightly encodes for HTML attributes. */
export declare function encodeLiteAttribute(text: string): string;
// File: functions/ensureMaxSize.d.ts
/** Resizes image if it exceeds max size. */
export declare function ensureMaxSize(file: Uint8Array, compress?: number, type?: string): Promise<string>;
// File: functions/escapeExp.d.ts
/** Escapes special regex characters. */
export declare function escapeExp(value: string): string;
// File: functions/eventStopPropagation.d.ts
/** Stops event propagation. */
export declare function eventStopPropagation(event: Event): void;
// File: functions/executeFunction.d.ts
/** Executes argument if function, else returns value. */
export declare function executeFunction<T>(callback: T | FunctionArgs<any, T>, ...args: any[]): T;
// File: functions/executePromise.d.ts
/** Safely executes function/Promise and awaits result. */
export declare function executePromise<T>(callback: ((...args: any[]) => Promise<T>) | ((...args: any[]) => T) | T, ...args: any[]): Promise<T>;
// File: functions/forEach.d.ts
/** Iterates and returns array of results. */
export declare function forEach<T, R, D extends T[] | Record<string, T> | Map<string, T> | Set<T> = T[] | Record<string, T> | Map<string, T> | Set<T>, K = D extends T[] ? number : string>(data: D & (T[] | Record<string, T> | Map<string, T> | Set<T>), callback: (item: T, key: K, dataMain: typeof data) => R, saveUndefined?: boolean): R[];
// File: functions/frame.d.ts
/** Loops requestAnimationFrame until next returns false. */
export declare function frame(callback: () => void, next?: () => boolean, end?: () => void): void;
// File: functions/getArrayHighlightMatch.d.ts
/** Splits string into segment array with match flags. */
export declare function getArrayHighlightMatch(value: string, search?: string | RegExp): HighlightMatchItem[];
// File: functions/getAttributes.d.ts
/** Gets attributes record of element. */
export declare function getAttributes<E extends ElementOrWindow>(element?: ElementOrString<E>): Record<string, string | undefined>;
// File: functions/getClipboardData.d.ts
/** Retrieves clipboard string. */
export declare function getClipboardData(event?: ClipboardEvent): Promise<string>;
// File: functions/getColumn.d.ts
/** Returns array of specific column values. */
export declare function getColumn<T, K extends keyof T>(array: ObjectOrArray<T>, column: K): (T[K] | undefined)[];
// File: functions/getCurrentDate.d.ts
/**
 * Returns current date string.
 * @remarks Client-side only recommended for SSR safety.
 */
export declare function getCurrentDate(format?: GeoDate): string;
// File: functions/getCurrentTime.d.ts
/**
 * Returns current timestamp ms.
 * @note Warning: Causes SSR hydration mismatch if used in rendering.
 */
export declare function getCurrentTime(): number;
// File: functions/getElement.d.ts
/** Returns first matched Element. */
export declare function getElement<E extends ElementOrWindow, R extends Exclude<E, Window>>(element?: ElementOrString<E>): R | undefined;
// File: functions/getElementId.d.ts
/** Gets or creates element ID. */
export declare function getElementId<E extends ElementOrWindow>(element?: ElementOrString<E>, selector?: string): string;
/**
 * Initializes getElementId.
 * @warning Mandatory for SSR.
 */
export declare function initGetElementId(newListener: () => string | number): void;
// File: functions/getElementImage.d.ts
/** Gets Image element from source. */
export declare function getElementImage(image: HTMLImageElement | string): HTMLImageElement | undefined;
// File: functions/getElementItem.d.ts
/** Returns element property value. */
export declare function getElementItem<T extends ElementOrWindow, K extends keyof T, D>(element: ElementOrString<T>, index: K | string, defaultValue?: D): T[K] | D | undefined;
// File: functions/getElementOrWindow.d.ts
/** Returns Window or Element. */
export declare function getElementOrWindow<E extends ElementOrWindow>(element?: ElementOrString<E>): E | undefined;
// File: functions/getElementSafeScript.d.ts
/** Generates script tag for hydration. */
export declare function getElementSafeScript(id: string, data: any): string;
// File: functions/getExactSearchExp.d.ts
/** Regex for exact case-insensitive phrase match. */
export declare function getExactSearchExp(search: string): RegExp;
// File: functions/getExp.d.ts
/** Creates RegExp from template. */
export declare function getExp(value: string, flags?: string, pattern?: string): RegExp;
// File: functions/getHydrationData.d.ts
/** Parses JSON from script tag. */
export declare function getHydrationData<T>(id: string, defaultValue: T, remove?: boolean): T;
// File: functions/getItemByPath.d.ts
/** Returns data by path string. */
export declare function getItemByPath<T extends Record<string, any>, R = string>(item: T, path: string): R | undefined;
// File: functions/getKey.d.ts
/** Returns pressed key. */
export declare function getKey(event: KeyboardEvent): string;
// File: functions/getLengthOfAllArray.d.ts
/** Returns lengths of all elements. */
export declare function getLengthOfAllArray(value: ObjectOrArray<string>): number[];
// File: functions/getMaxLengthAllArray.d.ts
/** Returns length of longest string. */
export declare function getLengthOfAllArray(value: ObjectOrArray<string>): number[];
export declare function getMaxLengthAllArray(data: ObjectOrArray<string>): number;
// File: functions/getMinLengthAllArray.d.ts
/** Returns length of shortest string. */
export declare function getMinLengthAllArray(data: ObjectOrArray<string>): number;
// File: functions/getMouseClient.d.ts
/** Returns mouse/click coordinates. */
export declare function getMouseClient(event: MouseEvent & TouchEvent): ImageCoordinator;
// File: functions/getMouseClientX.d.ts
/** Returns X coordinate. */
export declare function getMouseClientX(event: MouseEvent & TouchEvent): number;
// File: functions/getMouseClientY.d.ts
/** Returns Y coordinate. */
export declare function getMouseClientY(event: MouseEvent & TouchEvent): number;
// File: functions/getObjectByKeys.d.ts
/** New object with specified keys. */
export declare function getObjectByKeys<T extends Record<string, any>, K extends keyof T>(data: T, keys: K[]): Pick<T, K>;
// File: functions/getObjectNoUndefined.d.ts
/** Removes properties matching exception type. */
export declare function getObjectNoUndefined<T extends Record<string | number, any>>(data: T, exception?: any): T;
// File: functions/getObjectOrNone.d.ts
/** Returns object or empty object. */
export declare function getObjectOrNone<T>(value: T): T & Record<string, any>;
// File: functions/getOnlyText.d.ts
/** Keeps letters, numbers, spaces. */
export declare function getOnlyText(text: any): string;
// File: functions/getRandomText.d.ts
/** Generates random text. */
export declare function getRandomText(min: number, max: number, symbol?: string, lengthMin?: number, lengthMax?: number): string;
// File: functions/getRequestString.d.ts
/** Formats request as key-value string. */
export declare function getRequestString(request: Record<string, any> | any[], sign?: string, separator?: string, subKey?: string): string;
// File: functions/getSearchExp.d.ts
/** RegExp for "contains all words" search. */
export declare function getSearchExp(search: string, limit?: number): RegExp;
// File: functions/getSeparatingSearchExp.d.ts
/** RegExp for search by space-separated words. */
export declare function getSeparatingSearchExp(search: string | RegExp, limit?: number): RegExp;
// File: functions/getStepPercent.d.ts
/** Step unit in percent. */
export declare function getStepPercent(min: number | undefined, max: number): number;
// File: functions/getStepValue.d.ts
/** Step unit value. */
export declare function getStepValue(min: number | undefined, max: number): number;
// File: functions/goScroll.d.ts
/** Quick scroll to element. */
export declare function goScroll(selector: string, elementTo: HTMLElement | undefined, elementCenter?: HTMLElement): void;
// File: functions/goScrollSmooth.d.ts
/** Smooth scroll to element. */
export declare function goScrollSmooth<E extends HTMLElement>(element: E, options?: ScrollIntoViewOptions, shift?: number): void;
// File: functions/goScrollTo.d.ts
/** Scrolls container to target. */
export declare function goScrollTo(element?: HTMLElement, elementTo?: HTMLElement, behavior?: ScrollBehavior): void;
// File: functions/handleShare.d.ts
/** Web Share API wrapper. */
export declare function handleShare(data: ShareData): Promise<boolean>;
// File: functions/inArray.d.ts
/** Checks value in array. */
export declare function inArray<T>(array: T[], value: T): boolean;
// File: functions/initScrollbarOffset.d.ts
/** Init scroll control data. */
export declare function initScrollbarOffset(): Promise<void>;
// File: functions/intersectKey.d.ts
/** Intersection of arrays using keys. */
export declare function intersectKey<T, KT extends keyof T, C, KC extends keyof C>(data?: T, comparison?: C): Record<KT & KC, T[KT]>;
// File: functions/isApiSuccess.d.ts
/** Checks API success flag. */
export declare const isApiSuccess: <T>(data: ApiData<T>) => boolean;
// File: functions/isArray.d.ts
/** Checks if array. */
export declare function isArray<T, R>(value: T): value is Extract<T, R[]>;
// File: functions/isDifferent.d.ts
/** Checks object value difference. */
export declare function isDifferent<T>(value: ObjectItem<T>, old: ObjectItem<T>): boolean;
// File: functions/isDomData.d.ts
/** Checks for data URL environment. */
export declare function isDomData(): boolean;
// File: functions/isDomRuntime.d.ts
/** Checks if window available. */
export declare function isDomRuntime(): boolean;
// File: functions/isElementVisible.d.ts
/** Checks CSS visibility and DOM presence. */
export declare function isElementVisible<E extends ElementOrWindow>(elementSelectors?: ElementOrString<E>): boolean;
// File: functions/isEnter.d.ts
/** Checks Enter/Space key. */
export declare const isEnter: (event: KeyboardEvent, isInputElement?: boolean) => boolean;
// File: functions/isFilled.d.ts
/** Checks if field filled. */
export declare function isFilled<T>(value: T, zeroTrue?: boolean): value is Exclude<T, EmptyValue>;
// File: functions/isFloat.d.ts
/** Checks if numeric/float. */
export declare function isFloat(value: any): boolean;
// File: functions/isFunction.d.ts
/** Checks if function. */
export declare function isFunction<T>(callback: T): callback is Extract<T, FunctionArgs<any, any>>;
// File: functions/isInDom.d.ts
/** Checks DOM presence. */
export declare function isInDom<E extends ElementOrWindow>(element?: ElementOrString<E>): boolean;
// File: functions/isInput.d.ts
/** Checks if input/editable. */
export declare const isInput: (element: HTMLElement | EventTarget | null) => boolean;
// File: functions/isIntegerBetween.d.ts
/** Checks if between integers. */
export declare function isIntegerBetween(value: number, between: number): boolean;
// File: functions/isNull.d.ts
/** Checks null/undefined. */
export declare function isNull<T>(value: T): value is Extract<T, Undefined>;
// File: functions/isNumber.d.ts
/** Checks if number. */
export declare function isNumber(value: any): boolean;
// File: functions/isObject.d.ts
/** Checks if object. */
export declare function isObject<T>(value: T): value is Extract<T, Record<any, any>>;
// File: functions/isObjectNotArray.d.ts
/** Checks if object and not array. */
export declare function isObjectNotArray<T>(value: T): value is Exclude<Extract<T, Record<any, any>>, any[] | undefined | null>;
// File: functions/isOnLine.d.ts
/** Checks online status. */
export declare function isOnLine(): boolean;
// File: functions/isSelected.d.ts
/** Checks value in selected array/string. */
export declare function isSelected<T, S>(value: T, selected: T | T[] | S): boolean;
// File: functions/isSelectedByList.d.ts
/** Checks selection for entire list. */
export declare function isSelectedByList<T>(values: T | T[], selected: T | T[]): boolean;
// File: functions/isShare.d.ts
/** Checks Web Share API support. */
export declare function isShare(): boolean;
// File: functions/isString.d.ts
/** Checks if string. */
export declare function isString<T>(value: T): value is Extract<T, string>;
// File: functions/isWindow.d.ts
/** Checks if Window. */
export declare function isWindow<E>(element: E): element is Extract<E, Window>;
// File: functions/random.d.ts
/** Random integer generator. */
export declare function random(min: number, max: number): number;
// File: functions/removeCommonPrefix.d.ts
/** Removes prefix from string. */
export declare function removeCommonPrefix(mainStr: string, prefix: string): string;
// File: functions/replaceComponentName.d.ts
/** Replaces component name in text. */
export declare const replaceComponentName: (text: string | undefined, name: string, componentName: string) => string | undefined;
// File: functions/replaceRecursive.d.ts
/** Recursive merge of arrays/objects. */
export declare function replaceRecursive<I>(array: ObjectItem<I>, replacement?: ObjectOrArray<I>, isMerge?: boolean): ObjectItem<I>;
// File: functions/replaceTemplate.d.ts
/** Data-based template replacement. */
export declare function replaceTemplate(value: string, replaces: Record<string, string | FunctionReturn<string>>): string;
// File: functions/resizeImageByMax.d.ts
type ResizeImageByMaxType = 'auto' | 'width' | 'height';
/** Resizes image within max constraint. */
export declare function resizeImageByMax(image: HTMLImageElement | string, maxSize: number, type?: ResizeImageByMaxType, typeData?: string): string | undefined;
// File: functions/secondToTime.d.ts
/** Seconds to time string. */
export declare function secondToTime(second: number | string | undefined, hasHour?: boolean): string;
// File: functions/setElementItem.d.ts
/** Modifies element property. */
export declare function setElementItem<E extends ElementOrWindow, K extends keyof E, V extends E[K] = E[K]>(element: ElementOrString<E>, index: K, value: V | Record<string, V>): E | undefined;
// File: functions/setValues.d.ts
/** Modifies data by type and settings (multiple, maxlength). */
export declare function setValues<T>(selected: T | T[] | undefined, value: any, { multiple, maxlength, alwaysChange, notEmpty }: {
    multiple?: boolean | undefined;
    maxlength?: number | undefined;
    alwaysChange?: boolean | undefined;
    notEmpty?: boolean | undefined;
}): T | T[] | undefined;
// File: functions/sleep.d.ts
/** ms delay promise. */
export declare function sleep(ms: number): Promise<void>;
// File: functions/splice.d.ts
/** enumerable property copy into target object. */
export declare function splice<I>(array: ObjectItem<I>, replacement?: ObjectItem<I> | I, indexStart?: string): ObjectItem<I>;
// File: functions/strFill.d.ts
/** String of length count filled with value. */
export declare function strFill(value: string, count: number): string;
// File: functions/strSplit.d.ts
/** Splitting with limit. Last element contains remainder. */
export declare function strSplit(value: number | string, separator: string, limit?: number): string[];
// File: functions/toArray.d.ts
/** Wraps in array if not array. */
export declare function toArray<T>(value: T): T extends any[] ? T : [T];
// File: functions/toCamelCase.d.ts
/** Camel case (upper). */
export declare function toCamelCase(value: string): string;
// File: functions/toCamelCaseFirst.d.ts
/** Camel case with first letter upper. */
export declare function toCamelCaseFirst(value: string): string;
// File: functions/toDate.d.ts
/** Date object conversion. */
export declare function toDate<T extends Date | number | string>(value?: T): (T & Date) | Date;
// File: functions/toKebabCase.d.ts
/** Kebab-case conversion. */
export declare function toKebabCase(value: string): string;
// File: functions/toNumber.d.ts
/**
 * String/number to float. Handles separators.
 * @example toNumber("1 234,56") // 1234.56
 */
export declare function toNumber(value?: NumberOrString): number;
// File: functions/toNumberByMax.d.ts
/** Number conversion with max limit and formatting. */
export declare function toNumberByMax(value: string | number, max?: string | number, formatting?: boolean, language?: string): string | number;
// File: functions/toPercent.d.ts
/** Percentage conversion. */
export declare function toPercent(maxValue: number, value: number): number;
// File: functions/toPercentBy100.d.ts
/** Percentage * 100 conversion. */
export declare function toPercentBy100(maxValue: number, value: number): number;
// File: functions/toString.d.ts
/** String conversion. Empty if null/undefined. */
export declare function toString<T>(value: T): string;
// File: functions/transformation.d.ts
/** Transforms string to inferred type (null, boolean, object, function). */
export declare function transformation(value: any, isFunction?: boolean): any;
// File: functions/uint8ArrayToBase64.d.ts
/** Uint8Array to base64 string. */
export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
// File: functions/uniqueArray.d.ts
/** Removes duplicates. */
export declare function uniqueArray<T>(value: T[]): T[];
// File: functions/writeClipboardData.d.ts
/** Writes string to buffer. */
export declare function writeClipboardData(text: string): Promise<void>;
// File: types/apiTypes.d.ts
export declare enum ApiMethodItem {
    delete = "DELETE",
    get = "GET",
    post = "POST",
    put = "PUT",
    patch = "PATCH"
}
export type ApiCacheItem<T = any> = {
    value: T;
    age?: number;
    cacheAge: number;
};
export type ApiCacheList = Record<string, ApiCacheItem>;
export type ApiConfig = {
    urlRoot?: string;
    origin?: string;
    headers?: Record<string, string>;
    requestDefault?: Record<string, any>;
    preparation?: (apiFetch: ApiFetch) => Promise<void>;
    end?: (query: Response, apiFetch: ApiFetch) => Promise<ApiPreparationEnd>;
    timeout?: number;
};
export type ApiData<T = any> = T extends any[] ? T : ApiDataItem<T>;
export type ApiDataValidation = {
    status?: ApiStatusType;
    code?: string | number;
    message?: string;
};
export type ApiDataItem<T = any> = T & ApiDataValidation & {
    data?: T;
    success?: boolean;
    statusObject?: ApiStatusItem;
};
export type ApiDefaultValue = Record<string, any>;
export type ApiFetch = {
    api?: boolean;
    path?: string;
    pathFull?: string;
    method?: ApiMethod;
    request?: FormData | Record<string, any> | string;
    auth?: boolean;
    headers?: Record<string, string> | null;
    type?: string;
    toData?: boolean;
    global?: boolean;
    devMode?: boolean;
    hideError?: boolean;
    hideLoading?: boolean;
    retry?: number;
    retryDelay?: number;
    queryReturn?: (query: Response) => Promise<any | ApiDataValidation>;
    globalPreparation?: boolean;
    globalEnd?: boolean;
    init?: RequestInit;
    timeout?: number;
    controller?: AbortController;
    cache?: number;
    enableClientCache?: boolean;
    cacheId?: number | string;
    endResetLimit?: number;
};
export type ApiHydrationItem = {
    path: string;
    method: ApiMethod;
    request?: ApiFetch['request'];
    response: any;
};
export type ApiHydrationList = ApiHydrationItem[];
export type ApiMethod = string | ApiMethodItem;
export type ApiPreparationEnd = {
    reset?: boolean;
    data?: any;
};
export type ApiResponseItem = {
    path: string | RegExp;
    method: ApiMethod;
    request?: ApiFetch['request'] | '*any';
    response: any | ((request?: ApiFetch['request']) => any);
    disable?: any;
    isForGlobal?: boolean;
    lag?: any;
};
export type ApiStatusItem = {
    status?: number;
    statusText?: string;
    error?: string;
    lastResponse?: any;
    lastStatus?: ApiStatusType;
    lastCode?: string;
    lastMessage?: string;
};
export type ApiStatusType = 'success' | 'error' | 'warning' | 'info';
// File: types/basicTypes.d.ts
export type Undefined = undefined | null;
export type EmptyValue = Undefined | 0 | false | '' | 'undefined' | 'null' | '0' | 'false' | '[]';
export type NumberOrString = number | string;
export type NumberOrStringOrBoolean = number | string | boolean;
export type NumberOrStringOrDate = NumberOrString | Date;
export type NormalOrArray<T = NumberOrString> = T | T[];
export type NormalOrPromise<T> = T | Promise<T>;
export type ObjectItem<T = any> = Record<string, T>;
export type ObjectOrArray<T = any> = T[] | ObjectItem<T>;
export type ArrayToItem<T> = T extends any[] ? T[number] : T;
export type FunctionReturn<R = any> = () => R;
export type FunctionVoid = () => void;
export type FunctionArgs<T, R> = (...args: T[]) => R;
export type FunctionAnyType<T = any, R = any> = (...args: T[]) => R;
export type ItemList<T = any> = Record<string, T>;
export type Item<V> = {
    index: string;
    value: V;
};
export type ItemValue<V> = {
    label: string;
    value: V;
};
export type ItemName<V> = {
    name: string | number;
    value: V;
};
export type ElementOrWindow = HTMLElement | Window;
export type ElementOrString<E extends ElementOrWindow> = E | string;
export type EventOptions = AddEventListenerOptions | boolean | undefined;
export type EventListenerDetail<O extends Event, D extends Record<string, any>> = (event: O, detail?: D) => void;
export type EventActivityItem<E extends ElementOrWindow> = {
    element: E | undefined;
    type: string;
    listener?: (event: any | Event) => void;
    observer?: ResizeObserver;
};
export type ImageCoordinator = {
    x: number;
    y: number;
};
// File: types/errorCenter.d.ts
export type ErrorCenterGroup = string | undefined;
export type ErrorCenterCauseItem = {
    group?: ErrorCenterGroup;
    code: string;
    priority?: number;
    label?: string;
    message?: string;
    details?: any;
};
export type ErrorCenterCauseList = ErrorCenterCauseItem[];
export type ErrorCenterHandlerCallback = (cause: ErrorCenterCauseItem) => void;
export type ErrorCenterHandlerItem = {
    group?: ErrorCenterGroup;
    handlers: ErrorCenterHandlerCallback[];
};
export type ErrorCenterHandlerList = ErrorCenterHandlerItem[];
// File: types/formattersTypes.d.ts
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;
};
export type FormattersOptionsInformation<Type extends FormattersType> = Type extends FormattersType.currency ? FormattersOptionsCurrency : Type extends FormattersType.date ? FormattersOptionsDate : Type extends FormattersType.name ? FormattersOptionsName : Type extends FormattersType.number ? FormattersOptionsNumber : Type extends FormattersType.plural ? FormattersOptionsPlural : Type extends FormattersType.unit ? FormattersOptionsUnit : Record<string, any>;
export type FormattersOptionsItem<Type extends FormattersType = FormattersType, R = string> = {
    type?: Type;
    transformation?: (valueOriginal: any, item: any, options?: FormattersOptionsInformation<Type>) => R;
    options?: FormattersOptionsInformation<Type>;
};
export type FormattersOptionsList = Record<string, FormattersOptionsItem>;
export type FormattersListItem = Record<string, any>;
export type FormattersList<Item extends FormattersListItem> = Item[];
export type FormattersCapitalize<K extends string> = K extends `${infer First}.${infer Rest}` ? `${First}${Capitalize<FormattersCapitalize<Rest>>}` : K;
export type FormattersColumns<T extends FormattersOptionsList> = (keyof T & string)[];
export type FormattersKey<K, A extends string = 'Format'> = K extends string ? `${FormattersCapitalize<K>}${A}` : never;
export type FormattersDataItem<T extends FormattersListItem, KT extends string[]> = {
    [K in keyof T | FormattersKey<KT[number]>]: K extends keyof T ? T[K] : string;
};
export type FormattersListFormat<T extends FormattersListItem, K extends string[]> = FormattersDataItem<T, K>[];
export type FormattersListColumnItem<T extends FormattersListItem, O extends FormattersOptionsList> = FormattersDataItem<T, FormattersColumns<O>>;
export type FormattersListColumns<T extends FormattersListItem, O extends FormattersOptionsList> = FormattersListFormat<T, FormattersColumns<O>>;
export type FormattersListProp = FormattersList<FormattersListItem> | FormattersListItem;
export type FormattersItemProp<List extends FormattersListProp> = ArrayToItem<List>;
export type FormattersReturn<List extends FormattersListProp, Options extends FormattersOptionsList = FormattersOptionsList, Item extends FormattersItemProp<List> = FormattersItemProp<List>> = List extends any[] ? FormattersListColumns<Item, Options> : (FormattersListColumnItem<Item, Options> | undefined);
// File: types/geoTypes.d.ts
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';
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;
}
export interface GeoItemFull extends Omit<GeoItem, 'firstDay'> {
    standard: string;
    firstDay: string;
}
export interface GeoFlagItem {
    language: string;
    country: string;
    standard: string;
    icon?: string;
    label: string;
    value: string;
}
export interface GeoFlagNational extends GeoFlagItem {
    description: string;
    nationalLanguage: string;
    nationalCountry: string;
}
export interface GeoPhoneValue {
    phone: number;
    within: number;
    mask: string[];
    value: string;
}
export interface GeoPhoneMap {
    items: GeoPhoneValue[];
    info: GeoPhoneValue | undefined;
    value: string | undefined;
    mask: string[];
    maskFull: string[];
    next: Record<string, GeoPhoneMap>;
}
export interface GeoPhoneMapInfo {
    item?: GeoPhoneMap;
    phone?: string;
}
// File: types/metaTypes.d.ts
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"
}
// File: types/searchTypes.d.ts
export type SearchItem = Record<string, any>;
export type SearchColumnPath<K, P> = K extends string ? P extends string ? `${K}.${P}` : never : never;
export type SearchColumn<T extends SearchItem> = {
    [K in keyof T]-?: NonNullable<T[K]> extends object ? K | SearchColumnPath<K, keyof NonNullable<T[K]>> : K;
}[keyof T];
export type SearchColumns<T extends SearchItem> = (SearchColumn<T> & string)[];
export type SearchFormatCapitalize<K extends string> = K extends `${infer First}.${infer Rest}` ? `${First}${Capitalize<SearchFormatCapitalize<Rest>>}` : K;
export type SearchFormatKey<K> = K extends string ? `${SearchFormatCapitalize<K>}Search` : never;
export type SearchFormatItem<T extends SearchItem, KT extends string[]> = {
    [K in keyof T | SearchFormatKey<KT[number]>]: K extends keyof T ? T[K] : string;
} & {
    searchActive?: boolean;
};
export type SearchFormatList<T extends SearchItem, K extends string[]> = SearchFormatItem<T, K>[];
export type SearchListValue<T extends SearchItem> = T[] | undefined;
export type SearchOptions = {
    limit?: number;
    returnEverything?: boolean;
    delay?: number;
    findExactMatch?: boolean;
    classSearchName?: string;
};
export type SearchCacheItem<T extends SearchItem> = {
    item: T;
    value: string;
};
export type SearchCache<T extends SearchItem> = SearchCacheItem<T>[];
export type HighlightMatchItem = {
    text: string;
    isMatch: boolean;
};
// File: types/translateTypes.d.ts
export type TranslateConfig = {
    url?: string;
    propsName?: string;
    readApi?: boolean;
};
export type TranslateCode = string | string[];
export type TranslateList<T extends TranslateCode[]> = {
    [K in T[number] as K extends readonly string[] ? K[0] : K]: string;
};
export type TranslateItemOrList<T extends TranslateCode> = T extends string[] ? TranslateList<T> : string;
export type TranslateDataFileList = Record<string, string>;
export type TranslateDataFileItem = () => Promise<TranslateDataFileList>;
export type TranslateDataFile = Record<string, TranslateDataFileItem>;
export declare const TRANSLATE_GLOBAL_PREFIX = "global";
export declare const TRANSLATE_TIME_OUT = 160;
// File: media/errorCauseList.d.ts
export declare const errorCauseList: ErrorCenterCauseList;